#!/usr/bin/env python3 import requests import json import unittest import os import sys from datetime import datetime # Get the backend URL from the frontend .env file with open('/app/frontend/.env', 'r') as f: for line in f: if line.startswith('REACT_APP_BACKEND_URL='): BACKEND_URL = line.strip().split('=')[1].strip('"\'') break API_URL = f"{BACKEND_URL}/api" print(f"Testing Authentication API at: {API_URL}") class AuthenticationAPITest(unittest.TestCase): """Test suite for the Authentication System API""" def setUp(self): """Set up test fixtures before each test method""" self.test_username = "testuser_auth" self.test_password = "testpass123" self.admin_username = "admin" self.admin_password = "admin123" self.auth_token = None self.admin_token = None def test_01_health_check(self): """Test the health check endpoint""" print("\n--- Testing Health Check Endpoint ---") response = requests.get(f"{API_URL}/") self.assertEqual(response.status_code, 200, "Health check failed") data = response.json() self.assertEqual(data["message"], "Blog CMS API is running") self.assertEqual(data["status"], "healthy") print("✅ Health check endpoint working") def test_02_user_registration(self): """Test user registration with username and password""" print("\n--- Testing POST /api/auth/register ---") # Test successful registration registration_data = { "username": self.test_username, "password": self.test_password, "confirm_password": self.test_password } response = requests.post(f"{API_URL}/auth/register", json=registration_data) self.assertEqual(response.status_code, 200, f"Registration failed: {response.text}") data = response.json() self.assertEqual(data["message"], "User registered successfully") self.assertEqual(data["username"], self.test_username) self.assertEqual(data["roles"], ["Viewer"]) # Default role should be Viewer print(f"✅ User registration successful - Username: {self.test_username}, Default role: Viewer") def test_03_registration_password_mismatch(self): """Test registration with password mismatch""" print("\n--- Testing Registration Password Mismatch ---") registration_data = { "username": "testuser_mismatch", "password": "password123", "confirm_password": "different_password" } response = requests.post(f"{API_URL}/auth/register", json=registration_data) self.assertEqual(response.status_code, 400, "Password mismatch should return 400") data = response.json() self.assertEqual(data["detail"], "Passwords do not match") print("✅ Password mismatch validation working") def test_04_registration_duplicate_username(self): """Test registration with duplicate username""" print("\n--- Testing Registration Duplicate Username ---") registration_data = { "username": self.test_username, # Same username as test_02 "password": "newpassword123", "confirm_password": "newpassword123" } response = requests.post(f"{API_URL}/auth/register", json=registration_data) self.assertEqual(response.status_code, 400, "Duplicate username should return 400") data = response.json() self.assertEqual(data["detail"], "Username already registered") print("✅ Duplicate username validation working") def test_05_user_login_valid_credentials(self): """Test user login with valid credentials""" print("\n--- Testing POST /api/auth/login ---") # Login with the user we registered login_data = { "username": self.test_username, "password": self.test_password } response = requests.post(f"{API_URL}/auth/login", data=login_data) self.assertEqual(response.status_code, 200, f"Login failed: {response.text}") data = response.json() self.assertIn("access_token", data) self.assertEqual(data["token_type"], "bearer") self.assertIn("user", data) user_data = data["user"] self.assertEqual(user_data["username"], self.test_username) self.assertEqual(user_data["roles"], ["Viewer"]) self.assertTrue(user_data["is_active"]) # Store token for later tests self.auth_token = data["access_token"] print(f"✅ User login successful - JWT token generated, User: {self.test_username}") def test_06_user_login_invalid_credentials(self): """Test user login with invalid credentials""" print("\n--- Testing Login Invalid Credentials ---") # Test with wrong password login_data = { "username": self.test_username, "password": "wrongpassword" } response = requests.post(f"{API_URL}/auth/login", data=login_data) self.assertEqual(response.status_code, 401, "Invalid credentials should return 401") data = response.json() self.assertEqual(data["detail"], "Incorrect username or password") print("✅ Invalid credentials validation working") # Test with non-existent user login_data = { "username": "nonexistentuser", "password": "anypassword" } response = requests.post(f"{API_URL}/auth/login", data=login_data) self.assertEqual(response.status_code, 401, "Non-existent user should return 401") print("✅ Non-existent user validation working") def test_07_get_current_user_info(self): """Test GET /api/auth/me - current user info retrieval""" print("\n--- Testing GET /api/auth/me ---") # First login to get token if we don't have it if not self.auth_token: login_data = { "username": self.test_username, "password": self.test_password } response = requests.post(f"{API_URL}/auth/login", data=login_data) self.auth_token = response.json()["access_token"] # Test with valid token headers = {"Authorization": f"Bearer {self.auth_token}"} response = requests.get(f"{API_URL}/auth/me", headers=headers) self.assertEqual(response.status_code, 200, f"Get current user failed: {response.text}") data = response.json() self.assertEqual(data["username"], self.test_username) self.assertEqual(data["roles"], ["Viewer"]) self.assertTrue(data["is_active"]) self.assertIn("created_at", data) print(f"✅ Current user info retrieval successful - User: {self.test_username}") def test_08_get_current_user_no_token(self): """Test GET /api/auth/me without authentication token""" print("\n--- Testing GET /api/auth/me Without Token ---") response = requests.get(f"{API_URL}/auth/me") self.assertEqual(response.status_code, 401, "Request without token should return 401") print("✅ Unauthenticated request properly rejected") def test_09_get_current_user_invalid_token(self): """Test GET /api/auth/me with invalid token""" print("\n--- Testing GET /api/auth/me With Invalid Token ---") headers = {"Authorization": "Bearer invalid_token_here"} response = requests.get(f"{API_URL}/auth/me", headers=headers) self.assertEqual(response.status_code, 401, "Invalid token should return 401") data = response.json() self.assertEqual(data["detail"], "Could not validate credentials") print("✅ Invalid token properly rejected") def test_10_default_admin_user_login(self): """Test default admin user exists and can login""" print("\n--- Testing Default Admin User Login ---") login_data = { "username": self.admin_username, "password": self.admin_password } response = requests.post(f"{API_URL}/auth/login", data=login_data) self.assertEqual(response.status_code, 200, f"Admin login failed: {response.text}") data = response.json() self.assertIn("access_token", data) self.assertEqual(data["token_type"], "bearer") user_data = data["user"] self.assertEqual(user_data["username"], self.admin_username) self.assertIn("Admin", user_data["roles"]) self.assertTrue(user_data["is_active"]) # Store admin token for later tests self.admin_token = data["access_token"] print(f"✅ Default admin user login successful - Admin has proper permissions") def test_11_admin_get_all_users(self): """Test GET /api/auth/users - admin can list all users""" print("\n--- Testing GET /api/auth/users (Admin Only) ---") # First login as admin if we don't have token if not self.admin_token: login_data = { "username": self.admin_username, "password": self.admin_password } response = requests.post(f"{API_URL}/auth/login", data=login_data) self.admin_token = response.json()["access_token"] # Test with admin token headers = {"Authorization": f"Bearer {self.admin_token}"} response = requests.get(f"{API_URL}/auth/users", headers=headers) self.assertEqual(response.status_code, 200, f"Get all users failed: {response.text}") data = response.json() self.assertIsInstance(data, list, "Users response should be a list") self.assertGreater(len(data), 0, "Should have at least admin and test user") # Check that admin and test user are in the list usernames = [user["username"] for user in data] self.assertIn(self.admin_username, usernames) self.assertIn(self.test_username, usernames) print(f"✅ Admin can list all users - Found {len(data)} users") def test_12_non_admin_get_all_users(self): """Test GET /api/auth/users - non-admin cannot list users""" print("\n--- Testing GET /api/auth/users (Non-Admin Access) ---") # Use regular user token headers = {"Authorization": f"Bearer {self.auth_token}"} response = requests.get(f"{API_URL}/auth/users", headers=headers) self.assertEqual(response.status_code, 403, "Non-admin should get 403 Forbidden") data = response.json() self.assertEqual(data["detail"], "Insufficient permissions") print("✅ Non-admin properly denied access to user list") def test_13_admin_update_user_role(self): """Test PUT /api/auth/users/{user_id}/role - admin can update user roles""" print("\n--- Testing PUT /api/auth/users/{username}/role (Admin Only) ---") # Test updating test user's role to Author headers = {"Authorization": f"Bearer {self.admin_token}"} new_roles = ["Author", "Viewer"] response = requests.put( f"{API_URL}/auth/users/{self.test_username}/role", json=new_roles, headers=headers ) self.assertEqual(response.status_code, 200, f"Update user role failed: {response.text}") data = response.json() self.assertIn("roles updated", data["message"]) print(f"✅ Admin can update user roles - Updated {self.test_username} to {new_roles}") # Verify the role was actually updated by getting user info login_data = { "username": self.test_username, "password": self.test_password } response = requests.post(f"{API_URL}/auth/login", data=login_data) user_data = response.json()["user"] self.assertIn("Author", user_data["roles"]) print("✅ Role update verified through login") def test_14_admin_update_user_role_invalid_role(self): """Test PUT /api/auth/users/{username}/role with invalid role""" print("\n--- Testing Update User Role Invalid Role ---") headers = {"Authorization": f"Bearer {self.admin_token}"} invalid_roles = ["InvalidRole"] response = requests.put( f"{API_URL}/auth/users/{self.test_username}/role", json=invalid_roles, headers=headers ) self.assertEqual(response.status_code, 400, "Invalid role should return 400") data = response.json() self.assertEqual(data["detail"], "Invalid role specified") print("✅ Invalid role validation working") def test_15_admin_update_nonexistent_user_role(self): """Test PUT /api/auth/users/{username}/role for non-existent user""" print("\n--- Testing Update Non-existent User Role ---") headers = {"Authorization": f"Bearer {self.admin_token}"} new_roles = ["Viewer"] response = requests.put( f"{API_URL}/auth/users/nonexistentuser/role", json=new_roles, headers=headers ) self.assertEqual(response.status_code, 404, "Non-existent user should return 404") data = response.json() self.assertEqual(data["detail"], "User not found") print("✅ Non-existent user validation working") def test_16_non_admin_update_user_role(self): """Test PUT /api/auth/users/{username}/role - non-admin cannot update roles""" print("\n--- Testing Update User Role (Non-Admin Access) ---") headers = {"Authorization": f"Bearer {self.auth_token}"} new_roles = ["Publisher"] response = requests.put( f"{API_URL}/auth/users/{self.test_username}/role", json=new_roles, headers=headers ) self.assertEqual(response.status_code, 403, "Non-admin should get 403 Forbidden") data = response.json() self.assertEqual(data["detail"], "Insufficient permissions") print("✅ Non-admin properly denied role update access") def test_17_admin_delete_user(self): """Test DELETE /api/auth/users/{username} - admin can delete users""" print("\n--- Testing DELETE /api/auth/users/{username} (Admin Only) ---") # First create a user to delete delete_user_data = { "username": "user_to_delete", "password": "deletepass123", "confirm_password": "deletepass123" } response = requests.post(f"{API_URL}/auth/register", json=delete_user_data) self.assertEqual(response.status_code, 200, "Failed to create user for deletion test") # Now delete the user as admin headers = {"Authorization": f"Bearer {self.admin_token}"} response = requests.delete(f"{API_URL}/auth/users/user_to_delete", headers=headers) self.assertEqual(response.status_code, 200, f"Delete user failed: {response.text}") data = response.json() self.assertIn("deleted successfully", data["message"]) print("✅ Admin can delete users") # Verify user is actually deleted by trying to login login_data = { "username": "user_to_delete", "password": "deletepass123" } response = requests.post(f"{API_URL}/auth/login", data=login_data) self.assertEqual(response.status_code, 401, "Deleted user should not be able to login") print("✅ User deletion verified") def test_18_admin_delete_admin_user(self): """Test DELETE /api/auth/users/admin - cannot delete admin user""" print("\n--- Testing Delete Admin User Prevention ---") headers = {"Authorization": f"Bearer {self.admin_token}"} response = requests.delete(f"{API_URL}/auth/users/admin", headers=headers) self.assertEqual(response.status_code, 400, "Should not be able to delete admin user") data = response.json() self.assertEqual(data["detail"], "Cannot delete admin user") print("✅ Admin user deletion properly prevented") def test_19_admin_delete_nonexistent_user(self): """Test DELETE /api/auth/users/{username} for non-existent user""" print("\n--- Testing Delete Non-existent User ---") headers = {"Authorization": f"Bearer {self.admin_token}"} response = requests.delete(f"{API_URL}/auth/users/nonexistentuser", headers=headers) self.assertEqual(response.status_code, 404, "Non-existent user should return 404") data = response.json() self.assertEqual(data["detail"], "User not found") print("✅ Non-existent user deletion validation working") def test_20_non_admin_delete_user(self): """Test DELETE /api/auth/users/{username} - non-admin cannot delete users""" print("\n--- Testing Delete User (Non-Admin Access) ---") headers = {"Authorization": f"Bearer {self.auth_token}"} response = requests.delete(f"{API_URL}/auth/users/someuser", headers=headers) self.assertEqual(response.status_code, 403, "Non-admin should get 403 Forbidden") data = response.json() self.assertEqual(data["detail"], "Insufficient permissions") print("✅ Non-admin properly denied user deletion access") def test_21_password_validation(self): """Test password validation (minimum 6 characters)""" print("\n--- Testing Password Validation ---") # Test with short password registration_data = { "username": "shortpass_user", "password": "12345", # Only 5 characters "confirm_password": "12345" } response = requests.post(f"{API_URL}/auth/register", json=registration_data) # Note: The current implementation doesn't seem to have minimum length validation # This test documents the current behavior if response.status_code == 400: print("✅ Password length validation working") else: print("⚠️ Password length validation not implemented (current behavior)") def test_22_jwt_token_validation(self): """Test JWT token generation and validation""" print("\n--- Testing JWT Token Validation ---") # Login to get a fresh token login_data = { "username": self.test_username, "password": self.test_password } response = requests.post(f"{API_URL}/auth/login", data=login_data) token = response.json()["access_token"] # Verify token works for protected endpoint headers = {"Authorization": f"Bearer {token}"} response = requests.get(f"{API_URL}/auth/me", headers=headers) self.assertEqual(response.status_code, 200, "Valid token should work") # Test with malformed token headers = {"Authorization": "Bearer malformed.token.here"} response = requests.get(f"{API_URL}/auth/me", headers=headers) self.assertEqual(response.status_code, 401, "Malformed token should be rejected") print("✅ JWT token generation and validation working") def test_23_role_based_access_control(self): """Test role-based access control functionality""" print("\n--- Testing Role-Based Access Control ---") # Test that Viewer role can access /auth/me but not admin endpoints headers = {"Authorization": f"Bearer {self.auth_token}"} # Should work - basic authenticated endpoint response = requests.get(f"{API_URL}/auth/me", headers=headers) self.assertEqual(response.status_code, 200, "Viewer should access /auth/me") # Should fail - admin-only endpoint response = requests.get(f"{API_URL}/auth/users", headers=headers) self.assertEqual(response.status_code, 403, "Viewer should not access admin endpoints") # Test admin can access admin endpoints admin_headers = {"Authorization": f"Bearer {self.admin_token}"} response = requests.get(f"{API_URL}/auth/users", headers=admin_headers) self.assertEqual(response.status_code, 200, "Admin should access admin endpoints") print("✅ Role-based access control working correctly") if __name__ == "__main__": # Create a test suite suite = unittest.TestSuite() # Add all authentication tests in order test_methods = [ "test_01_health_check", "test_02_user_registration", "test_03_registration_password_mismatch", "test_04_registration_duplicate_username", "test_05_user_login_valid_credentials", "test_06_user_login_invalid_credentials", "test_07_get_current_user_info", "test_08_get_current_user_no_token", "test_09_get_current_user_invalid_token", "test_10_default_admin_user_login", "test_11_admin_get_all_users", "test_12_non_admin_get_all_users", "test_13_admin_update_user_role", "test_14_admin_update_user_role_invalid_role", "test_15_admin_update_nonexistent_user_role", "test_16_non_admin_update_user_role", "test_17_admin_delete_user", "test_18_admin_delete_admin_user", "test_19_admin_delete_nonexistent_user", "test_20_non_admin_delete_user", "test_21_password_validation", "test_22_jwt_token_validation", "test_23_role_based_access_control" ] for test_method in test_methods: suite.addTest(AuthenticationAPITest(test_method)) # Run the tests runner = unittest.TextTestRunner(verbosity=2) result = runner.run(suite) # Print summary print(f"\n{'='*60}") print(f"AUTHENTICATION SYSTEM TEST SUMMARY") print(f"{'='*60}") print(f"Tests run: {result.testsRun}") print(f"Failures: {len(result.failures)}") print(f"Errors: {len(result.errors)}") if result.failures: print(f"\nFAILURES:") for test, traceback in result.failures: print(f"- {test}: {traceback}") if result.errors: print(f"\nERRORS:") for test, traceback in result.errors: print(f"- {test}: {traceback}") if result.wasSuccessful(): print(f"\n✅ ALL AUTHENTICATION TESTS PASSED!") else: print(f"\n❌ SOME AUTHENTICATION TESTS FAILED!")

# Backend package

#!/usr/bin/env python3 import sys import os sys.path.append('/app/backend') from sqlalchemy import create_engine, text from database import DATABASE_URL def add_artists_column(): """Add artists column to articles table""" try: # Create engine engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False}) print("🔄 Adding artists column to articles table...") # Add artists column (TEXT to store JSON array) with engine.connect() as connection: # Check if column already exists result = connection.execute(text(""" PRAGMA table_info(articles) """)) columns = [row[1] for row in result.fetchall()] if 'artists' in columns: print("✅ Artists column already exists in articles table") return # Add the column connection.execute(text(""" ALTER TABLE articles ADD COLUMN artists TEXT """)) connection.commit() print("✅ Successfully added artists column to articles table") except Exception as e: print(f"❌ Error adding artists column: {str(e)}") raise if __name__ == "__main__": add_artists_column()

#!/usr/bin/env python3 """ Migration script to add content_type column to articles table """ import sys import os sys.path.append(os.path.dirname(os.path.abspath(__file__))) from sqlalchemy import text from database import engine, SessionLocal def add_content_type_column(): """Add content_type column to articles table""" db = SessionLocal() try: print("Adding content_type column to articles table...") # Check if column already exists result = db.execute(text(""" SELECT COUNT(*) as count FROM pragma_table_info('articles') WHERE name = 'content_type' """)).fetchone() if result.count > 0: print("✓ content_type column already exists!") return # Add the content_type column with default value 'post' db.execute(text(""" ALTER TABLE articles ADD COLUMN content_type VARCHAR DEFAULT 'post' """)) # Update existing articles to have 'post' as default content_type db.execute(text(""" UPDATE articles SET content_type = 'post' WHERE content_type IS NULL """)) db.commit() print("✓ Successfully added content_type column to articles table") print("✓ All existing articles set to content_type='post'") # Verify the column was added result = db.execute(text("SELECT COUNT(*) as count FROM articles WHERE content_type = 'post'")).fetchone() print(f"✓ Verified: {result.count} articles now have content_type='post'") except Exception as e: print(f"✗ Error adding content_type column: {e}") db.rollback() raise finally: db.close() if __name__ == "__main__": add_content_type_column() print("Migration completed successfully!")

#!/usr/bin/env python3 """ Add gallery_id column to articles table """ from sqlalchemy import text from database import get_db def add_gallery_id_column(): """Add gallery_id column to articles table""" db = next(get_db()) try: # Check if column already exists result = db.execute(text("PRAGMA table_info(articles)")).fetchall() columns = [row[1] for row in result] # row[1] is column name if 'gallery_id' not in columns: # Add the column db.execute(text("ALTER TABLE articles ADD COLUMN gallery_id INTEGER")) db.commit() print("✅ Successfully added gallery_id column to articles table") else: print("✅ gallery_id column already exists in articles table") except Exception as e: print(f"❌ Error adding gallery_id column: {e}") db.rollback() finally: db.close() if __name__ == "__main__": add_gallery_id_column()

#!/usr/bin/env python3 """ Add image_gallery column to articles table """ from sqlalchemy import text from database import get_db def add_image_gallery_column(): """Add image_gallery column to articles table""" db = next(get_db()) try: # Check if column already exists result = db.execute(text("PRAGMA table_info(articles)")).fetchall() columns = [row[1] for row in result] # row[1] is column name if 'image_gallery' not in columns: # Add the column db.execute(text("ALTER TABLE articles ADD COLUMN image_gallery TEXT")) db.commit() print("✅ Successfully added image_gallery column to articles table") else: print("✅ image_gallery column already exists in articles table") except Exception as e: print(f"❌ Error adding image_gallery column: {e}") db.rollback() finally: db.close() if __name__ == "__main__": add_image_gallery_column()

#!/usr/bin/env python3 import os import sys from sqlalchemy import create_engine, text from sqlalchemy.orm import sessionmaker # Add the backend directory to the path so we can import our modules sys.path.append(os.path.dirname(os.path.abspath(__file__))) from database import DATABASE_URL def add_movie_rating_column(): """Add movie_rating column to articles table""" # Create engine engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False}) # Create session SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) session = SessionLocal() try: # Check if column already exists (SQLite specific) result = session.execute(text(""" PRAGMA table_info(articles) """)) columns = [row[1] for row in result.fetchall()] if 'movie_rating' in columns: print("movie_rating column already exists in articles table") return # Add movie_rating column (SQLite specific) session.execute(text(""" ALTER TABLE articles ADD COLUMN movie_rating TEXT DEFAULT NULL """)) session.commit() print("Successfully added movie_rating column to articles table") except Exception as e: session.rollback() print(f"Error adding movie_rating column: {e}") raise finally: session.close() if __name__ == "__main__": add_movie_rating_column()

import os from datetime import datetime, timedelta from typing import List from jose import JWTError, jwt from passlib.context import CryptContext from fastapi.security import OAuth2PasswordBearer from fastapi import Depends, HTTPException, status from motor.motor_asyncio import AsyncIOMotorClient from bson import ObjectId from models.auth_models import UserInDB, UserResponse # Configuration SECRET_KEY = os.environ.get("SECRET_KEY", "tadka-secret-key-change-in-production") ALGORITHM = "HS256" ACCESS_TOKEN_EXPIRE_MINUTES = 480 # 8 hours # Password hashing pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto") # OAuth2 scheme oauth2_scheme = OAuth2PasswordBearer(tokenUrl="api/auth/login") # MongoDB connection MONGO_URL = os.environ.get("MONGO_URL", "mongodb://localhost:27017") DB_NAME = os.environ.get("DB_NAME", "test_database") client = AsyncIOMotorClient(MONGO_URL) db = client[DB_NAME] users_collection = db.users def verify_password(plain_password: str, hashed_password: str) -> bool: """Verify a plain password against a hashed password""" return pwd_context.verify(plain_password, hashed_password) def get_password_hash(password: str) -> str: """Hash a password""" return pwd_context.hash(password) def create_access_token(data: dict, expires_delta: timedelta = None) -> str: """Create JWT access token""" to_encode = data.copy() if expires_delta: expire = datetime.utcnow() + expires_delta else: expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) to_encode.update({"exp": expire}) encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM) return encoded_jwt async def get_user_by_username(username: str) -> UserInDB: """Get user from database by username""" user_data = await users_collection.find_one({"username": username}) if user_data: user_data["_id"] = str(user_data["_id"]) return UserInDB(**user_data) return None async def authenticate_user(username: str, password: str) -> UserInDB: """Authenticate user with username and password""" user = await get_user_by_username(username) if not user: return False if not verify_password(password, user.hashed_password): return False return user async def get_current_user(token: str = Depends(oauth2_scheme)) -> UserResponse: """Get current user from JWT token""" credentials_exception = HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="Could not validate credentials", headers={"WWW-Authenticate": "Bearer"}, ) try: payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM]) username: str = payload.get("sub") if username is None: raise credentials_exception except JWTError: raise credentials_exception user = await get_user_by_username(username) if user is None: raise credentials_exception return UserResponse( username=user.username, roles=user.roles, created_at=user.created_at, is_active=user.is_active ) async def get_current_active_user(current_user: UserResponse = Depends(get_current_user)) -> UserResponse: """Get current active user""" if not current_user.is_active: raise HTTPException(status_code=400, detail="Inactive user") return current_user # Role-based access control def require_roles(required_roles: List[str]): """Decorator to require specific roles""" async def role_checker(current_user: UserResponse = Depends(get_current_active_user)): if not any(role in current_user.roles for role in required_roles): raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail="Insufficient permissions" ) return current_user return role_checker # Role dependencies require_admin = require_roles(["Admin"]) require_publisher = require_roles(["Publisher", "Admin"]) require_author = require_roles(["Author", "Publisher", "Admin"]) require_viewer = require_roles(["Viewer", "Author", "Publisher", "Admin"]) async def create_default_admin(): """Create default admin user if it doesn't exist""" admin_exists = await users_collection.find_one({"username": "admin"}) if not admin_exists: admin_user = { "username": "admin", "hashed_password": get_password_hash("admin123"), "roles": ["Admin"], "created_at": datetime.utcnow(), "is_active": True, "password": "admin123" # This will be removed after hashing } del admin_user["password"] # Remove plain password await users_collection.insert_one(admin_user) print("✅ Default admin user created: username='admin', password='admin123'") return True return False

#!/usr/bin/env python3 import sys import os sys.path.append('/app/backend') from sqlalchemy import create_engine, text from database import DATABASE_URL def create_gallery_tables(): """Create galleries table and gallery_topics association table""" try: # Create engine engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False}) print("🔄 Creating gallery tables...") with engine.connect() as connection: # Check if galleries table already exists result = connection.execute(text(""" SELECT name FROM sqlite_master WHERE type='table' AND name='galleries' """)) if result.fetchone(): print("✅ Galleries table already exists") else: # Create galleries table connection.execute(text(""" CREATE TABLE galleries ( id INTEGER PRIMARY KEY, gallery_id VARCHAR UNIQUE NOT NULL, title VARCHAR NOT NULL, artists TEXT, images TEXT NOT NULL, gallery_type VARCHAR DEFAULT 'vertical', created_at DATETIME DEFAULT CURRENT_TIMESTAMP, updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ) """)) # Create index on gallery_id connection.execute(text(""" CREATE INDEX ix_galleries_gallery_id ON galleries (gallery_id) """)) # Create index on title connection.execute(text(""" CREATE INDEX ix_galleries_title ON galleries (title) """)) print("✅ Created galleries table") # Check if gallery_topics table already exists result = connection.execute(text(""" SELECT name FROM sqlite_master WHERE type='table' AND name='gallery_topics' """)) if result.fetchone(): print("✅ Gallery_topics association table already exists") else: # Create gallery_topics association table connection.execute(text(""" CREATE TABLE gallery_topics ( gallery_id INTEGER NOT NULL, topic_id INTEGER NOT NULL, PRIMARY KEY (gallery_id, topic_id), FOREIGN KEY (gallery_id) REFERENCES galleries (id), FOREIGN KEY (topic_id) REFERENCES topics (id) ) """)) print("✅ Created gallery_topics association table") connection.commit() print("✅ Successfully created all gallery tables") except Exception as e: print(f"❌ Error creating gallery tables: {str(e)}") raise if __name__ == "__main__": create_gallery_tables()

#!/usr/bin/env python3 import sys import os from sqlalchemy import create_engine, text from database import DATABASE_URL from models.database_models import Base, Topic, TopicCategory, article_topic_association def create_topics_tables(): """Create topics and topic_categories tables""" print("🗄️ Creating Topics tables...") # Create engine engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False}) try: with engine.connect() as connection: # Create topics table print("📝 Creating topics table...") connection.execute(text(""" CREATE TABLE IF NOT EXISTS topics ( id INTEGER PRIMARY KEY, title VARCHAR NOT NULL, slug VARCHAR UNIQUE NOT NULL, description TEXT, category VARCHAR NOT NULL, image VARCHAR, language VARCHAR DEFAULT 'en', created_at DATETIME DEFAULT CURRENT_TIMESTAMP, updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ) """)) # Create topic_categories table print("📝 Creating topic_categories table...") connection.execute(text(""" CREATE TABLE IF NOT EXISTS topic_categories ( id INTEGER PRIMARY KEY, name VARCHAR UNIQUE NOT NULL, slug VARCHAR UNIQUE NOT NULL, created_at DATETIME DEFAULT CURRENT_TIMESTAMP ) """)) # Create article_topics association table print("📝 Creating article_topics association table...") connection.execute(text(""" CREATE TABLE IF NOT EXISTS article_topics ( article_id INTEGER, topic_id INTEGER, PRIMARY KEY (article_id, topic_id), FOREIGN KEY (article_id) REFERENCES articles(id), FOREIGN KEY (topic_id) REFERENCES topics(id) ) """)) # Insert default topic categories print("📝 Inserting default topic categories...") connection.execute(text(""" INSERT OR IGNORE INTO topic_categories (name, slug) VALUES ('Movies', 'movies'), ('Politics', 'politics'), ('Sports', 'sports'), ('TV', 'tv'), ('Travel', 'travel') """)) connection.commit() print("✅ Topics tables created successfully!") except Exception as e: print(f"❌ Error creating topics tables: {e}") sys.exit(1) finally: engine.dispose() if __name__ == "__main__": create_topics_tables()

#!/usr/bin/env python3 import sys import os sys.path.append(os.path.dirname(os.path.abspath(__file__))) from sqlalchemy.orm import Session from database import get_db import models def create_viral_categories(): db: Session = next(get_db()) try: # Check if categories already exist existing_usa = db.query(models.Category).filter(models.Category.slug == 'usa').first() existing_row = db.query(models.Category).filter(models.Category.slug == 'row').first() existing_viral_shorts = db.query(models.Category).filter(models.Category.slug == 'viral-shorts').first() categories_to_create = [] # Create USA category if not existing_usa: categories_to_create.append(models.Category( name='USA', slug='usa', description='Videos and content related to USA' )) # Create ROW (Rest of World) category if not existing_row: categories_to_create.append(models.Category( name='ROW', slug='row', description='Videos and content from Rest of World' )) # Create Viral Shorts category if not existing_viral_shorts: categories_to_create.append(models.Category( name='Viral Shorts', slug='viral-shorts', description='Viral short format videos - state specific content' )) if categories_to_create: for category in categories_to_create: db.add(category) print(f"Creating category: {category.name} (slug: {category.slug})") db.commit() print(f"Successfully created {len(categories_to_create)} categories") else: print("All categories already exist") except Exception as e: print(f"Error creating categories: {e}") db.rollback() finally: db.close() if __name__ == "__main__": create_viral_categories()

#!/usr/bin/env python3 import sys import os sys.path.append(os.path.dirname(os.path.abspath(__file__))) from sqlalchemy.orm import Session from database import get_db import models def create_viral_shorts_bollywood_category(): db: Session = next(get_db()) try: # Check if category already exists existing_category = db.query(models.Category).filter(models.Category.slug == 'viral-shorts-bollywood').first() if not existing_category: # Create Viral Shorts Bollywood category new_category = models.Category( name='Viral Shorts Bollywood', slug='viral-shorts-bollywood', description='Bollywood short format viral videos - vertical content' ) db.add(new_category) db.commit() print(f"Successfully created category: {new_category.name} (slug: {new_category.slug})") else: print("Viral Shorts Bollywood category already exists") except Exception as e: print(f"Error creating category: {e}") db.rollback() finally: db.close() if __name__ == "__main__": create_viral_shorts_bollywood_category()

from sqlalchemy.orm import Session import models, schemas from typing import List, Optional from sqlalchemy import desc, and_, or_ from datetime import datetime import json # Category CRUD operations def get_category(db: Session, category_id: int): return db.query(models.Category).filter(models.Category.id == category_id).first() def get_category_by_slug(db: Session, slug: str): return db.query(models.Category).filter(models.Category.slug == slug).first() def get_categories(db: Session, skip: int = 0, limit: int = 100): return db.query(models.Category).offset(skip).limit(limit).all() def get_all_categories(db: Session): """Get all categories for CMS dropdown""" return db.query(models.Category).all() def create_category(db: Session, category: schemas.CategoryCreate): db_category = models.Category( name=category.name, slug=category.slug, description=category.description ) db.add(db_category) db.commit() db.refresh(db_category) return db_category # Article CRUD operations def get_article(db: Session, article_id: int): # Increment view count when getting a specific article article = db.query(models.Article).filter(models.Article.id == article_id).first() if article: article.view_count += 1 db.commit() db.refresh(article) return article def get_articles(db: Session, skip: int = 0, limit: int = 100, is_featured: Optional[bool] = None): query = db.query(models.Article) if is_featured is not None: query = query.filter(models.Article.is_featured == is_featured) return query.order_by(desc(models.Article.published_at)).offset(skip).limit(limit).all() def get_articles_by_category_slug(db: Session, category_slug: str, skip: int = 0, limit: int = 100): return db.query(models.Article).filter( models.Article.category == category_slug ).order_by(desc(models.Article.published_at)).offset(skip).limit(limit).all() def get_articles_by_states(db: Session, category_slug: str, state_codes: List[str], skip: int = 0, limit: int = 100): """Get articles filtered by state codes - returns articles that match user's states OR are universal (states=null) Args: db: Database session category_slug: Category to filter by (e.g., "state-politics") state_codes: List of state codes to match (e.g., ["ap", "ts"]) skip: Offset for pagination limit: Maximum number of articles to return Returns: List of articles that either: 1. Have states=null (universal articles) 2. Have states field containing any of the specified state codes """ from sqlalchemy import or_, and_ # Build query conditions conditions = [] # Condition 1: Universal articles (states is null) conditions.append(models.Article.states.is_(None)) # Condition 2: Articles with matching state codes for state_code in state_codes: # Check if states field contains the state code # Handle both JSON string format and direct matching conditions.append(models.Article.states.like(f'%"{state_code}"%')) conditions.append(models.Article.states.like(f'%{state_code}%')) return db.query(models.Article).filter( and_( models.Article.category == category_slug, or_(*conditions) ) ).order_by(desc(models.Article.published_at)).offset(skip).limit(limit).all() def get_most_read_articles(db: Session, limit: int = 100): return db.query(models.Article).order_by(desc(models.Article.view_count)).limit(limit).all() def create_article(db: Session, article: schemas.ArticleCreate): db_article = models.Article(**article.dict()) db.add(db_article) db.commit() db.refresh(db_article) return db_article # Movie Review CRUD operations def get_movie_review(db: Session, review_id: int): return db.query(models.MovieReview).filter(models.MovieReview.id == review_id).first() def get_movie_reviews(db: Session, skip: int = 0, limit: int = 100): return db.query(models.MovieReview).order_by(desc(models.MovieReview.published_at)).offset(skip).limit(limit).all() def create_movie_review(db: Session, review: schemas.MovieReviewCreate): db_review = models.MovieReview(**review.dict()) db.add(db_review) db.commit() db.refresh(db_review) return db_review # Featured Images CRUD operations def get_featured_images(db: Session, limit: int = 100): return db.query(models.FeaturedImage).filter( models.FeaturedImage.is_active == True ).order_by(models.FeaturedImage.display_order).limit(limit).all() def create_featured_image(db: Session, image: schemas.FeaturedImageCreate): db_image = models.FeaturedImage(**image.dict()) db.add(db_image) db.commit() db.refresh(db_image) return db_image # CMS-specific CRUD operations def get_articles_for_cms(db: Session, language: str = "en", skip: int = 0, limit: int = 20, category: str = None, state: str = None): """Get articles for CMS dashboard with filtering""" query = db.query(models.Article).filter(models.Article.language == language) if category: query = query.filter(models.Article.category == category) if state: # Map display state names to database state codes (31 states - AP & Telangana split) state_code_map = { 'Andhra Pradesh': 'ap', 'Arunachal Pradesh': 'ar', 'Assam': 'as', 'Bihar': 'br', 'Chhattisgarh': 'cg', 'Delhi': 'dl', 'Goa': 'ga', 'Gujarat': 'gj', 'Haryana': 'hr', 'Himachal Pradesh': 'hp', 'Jammu and Kashmir': 'jk', 'Jharkhand': 'jh', 'Karnataka': 'ka', 'Kerala': 'kl', 'Ladakh': 'ld', 'Madhya Pradesh': 'mp', 'Maharashtra': 'mh', 'Manipur': 'mn', 'Meghalaya': 'ml', 'Mizoram': 'mz', 'Nagaland': 'nl', 'Odisha': 'or', 'Punjab': 'pb', 'Rajasthan': 'rj', 'Sikkim': 'sk', 'Tamil Nadu': 'tn', 'Telangana': 'ts', 'Tripura': 'tr', 'Uttar Pradesh': 'up', 'Uttarakhand': 'uk', 'West Bengal': 'wb', # Legacy support for existing articles 'AP & Telangana': 'ap_ts' } state_code = state_code_map.get(state, state.lower()) # Filter articles where states field contains the state code query = query.filter( models.Article.states.like(f'%"{state_code}"%') ) return query.order_by(desc(models.Article.created_at)).offset(skip).limit(limit).all() def create_article_cms(db: Session, article: schemas.ArticleCreate, slug: str, seo_title: str, seo_description: str): """Create article via CMS""" # Handle scheduling logic published_at = None if article.is_scheduled and article.scheduled_publish_at: # Scheduled post - don't set published_at, keep is_published as False is_published = False elif article.is_published: # Regular published post published_at = datetime.utcnow() is_published = True else: # Draft post is_published = False db_article = models.Article( title=article.title, short_title=article.short_title, slug=slug, content=article.content, summary=article.summary, author=article.author, language=article.language, states=article.states, category=article.category, content_type=article.content_type, # Add content_type field image=article.image, youtube_url=article.youtube_url, tags=article.tags, artists=article.artists, # Add artists field movie_rating=article.movie_rating, # Add movie_rating field is_featured=article.is_featured, is_published=is_published, is_scheduled=article.is_scheduled, scheduled_publish_at=article.scheduled_publish_at, seo_title=seo_title, seo_description=seo_description, seo_keywords=article.seo_keywords, published_at=published_at ) db.add(db_article) db.commit() db.refresh(db_article) return db_article def update_article_cms(db: Session, article_id: int, article_update: schemas.ArticleUpdate): """Update article via CMS""" db_article = db.query(models.Article).filter(models.Article.id == article_id).first() update_data = article_update.dict(exclude_unset=True) # Handle scheduling logic if 'is_scheduled' in update_data or 'scheduled_publish_at' in update_data or 'is_published' in update_data: if update_data.get('is_scheduled') and update_data.get('scheduled_publish_at'): # Setting up as scheduled post update_data['is_published'] = False update_data['published_at'] = None elif update_data.get('is_published') is True: # Publishing immediately - always set current timestamp update_data['is_scheduled'] = False update_data['published_at'] = datetime.utcnow() # Update updated_at update_data['updated_at'] = datetime.utcnow() for field, value in update_data.items(): setattr(db_article, field, value) db.commit() db.refresh(db_article) return db_article def delete_article(db: Session, article_id: int): """Delete article""" db_article = db.query(models.Article).filter(models.Article.id == article_id).first() db.delete(db_article) db.commit() return db_article def create_translated_article(db: Session, original_article: models.Article, target_language: str): """Create translated version of article""" # Generate new slug with language suffix original_slug = original_article.slug new_slug = f"{original_slug}-{target_language}" translated_article = models.Article( title=f"[{target_language.upper()}] {original_article.title}", # Placeholder for actual translation short_title=original_article.short_title, slug=new_slug, content=original_article.content, # This would be translated by translation service summary=original_article.summary, # This would be translated by translation service author=original_article.author, language=target_language, states=original_article.states, category=original_article.category, image=original_article.image, youtube_url=original_article.youtube_url, tags=original_article.tags, is_featured=original_article.is_featured, is_published=False, # Set as draft initially original_article_id=original_article.id, seo_title=original_article.seo_title, seo_description=original_article.seo_description, seo_keywords=original_article.seo_keywords ) db.add(translated_article) db.commit() db.refresh(translated_article) return translated_article def get_article_by_id(db: Session, article_id: int): """Get article by ID for CMS""" return db.query(models.Article).filter(models.Article.id == article_id).first() # Scheduler CRUD operations def get_scheduler_settings(db: Session): """Get scheduler settings""" return db.query(models.SchedulerSettings).first() def create_scheduler_settings(db: Session, settings: schemas.SchedulerSettingsCreate): """Create initial scheduler settings""" db_settings = models.SchedulerSettings(**settings.dict()) db.add(db_settings) db.commit() db.refresh(db_settings) return db_settings def update_scheduler_settings(db: Session, settings_update: schemas.SchedulerSettingsUpdate): """Update scheduler settings""" db_settings = db.query(models.SchedulerSettings).first() if not db_settings: # Create default settings if none exist db_settings = models.SchedulerSettings() db.add(db_settings) update_data = settings_update.dict(exclude_unset=True) update_data['updated_at'] = datetime.utcnow() for field, value in update_data.items(): setattr(db_settings, field, value) db.commit() db.refresh(db_settings) return db_settings def get_scheduled_articles_for_publishing(db: Session): """Get articles that are scheduled and ready to be published""" from pytz import timezone ist = timezone('Asia/Kolkata') current_time_ist = datetime.now(ist).replace(tzinfo=None) return db.query(models.Article).filter( and_( models.Article.is_scheduled == True, models.Article.is_published == False, models.Article.scheduled_publish_at <= current_time_ist ) ).all() def publish_scheduled_article(db: Session, article_id: int): """Publish a scheduled article""" db_article = db.query(models.Article).filter(models.Article.id == article_id).first() if db_article: db_article.is_scheduled = False db_article.is_published = True db_article.published_at = datetime.utcnow() db.commit() db.refresh(db_article) return db_article # Related Articles Configuration CRUD operations def get_related_articles_config(db: Session, page_slug: str = None): """Get related articles configuration for a specific page or all pages""" if page_slug: return db.query(models.RelatedArticlesConfig).filter( models.RelatedArticlesConfig.page_slug == page_slug ).first() else: # Return all configurations as a dictionary configs = db.query(models.RelatedArticlesConfig).all() result = {} for config in configs: try: categories = json.loads(config.categories) if config.categories else [] except json.JSONDecodeError: categories = [] result[config.page_slug] = { 'categories': categories, 'articleCount': config.article_count } return result def create_or_update_related_articles_config(db: Session, config_data: schemas.RelatedArticlesConfigCreate): """Create or update related articles configuration""" # Check if configuration already exists existing_config = db.query(models.RelatedArticlesConfig).filter( models.RelatedArticlesConfig.page_slug == config_data.page ).first() categories_json = json.dumps(config_data.categories) if existing_config: # Update existing configuration existing_config.categories = categories_json existing_config.article_count = config_data.articleCount existing_config.updated_at = datetime.utcnow() db.commit() db.refresh(existing_config) return existing_config else: # Create new configuration db_config = models.RelatedArticlesConfig( page_slug=config_data.page, categories=categories_json, article_count=config_data.articleCount ) db.add(db_config) db.commit() db.refresh(db_config) return db_config def delete_related_articles_config(db: Session, page_slug: str): """Delete related articles configuration for a page""" db_config = db.query(models.RelatedArticlesConfig).filter( models.RelatedArticlesConfig.page_slug == page_slug ).first() if db_config: db.delete(db_config) db.commit() return db_config def get_related_articles_for_page(db: Session, page_slug: str, limit: int = None): """Get related articles for a specific page based on its configuration""" # Get the configuration for this page config = get_related_articles_config(db, page_slug) if not config: # Return empty list if no configuration found return [] try: categories = json.loads(config.categories) if config.categories else [] except json.JSONDecodeError: categories = [] if not categories: return [] # Use configured article count or provided limit (per category, not total) articles_per_category = limit if limit is not None else config.article_count # Get articles from each configured category (articles_per_category from each) all_articles = [] for category in categories: category_articles = db.query(models.Article).filter( and_( models.Article.category == category, models.Article.is_published == True ) ).order_by(desc(models.Article.published_at)).limit(articles_per_category).all() all_articles.extend(category_articles) # Sort all articles by published date and return all_articles.sort(key=lambda x: x.published_at or datetime.min, reverse=True) return all_articles # Theater Release CRUD operations def get_theater_releases(db: Session, skip: int = 0, limit: int = 100): return db.query(models.TheaterRelease).order_by(desc(models.TheaterRelease.release_date)).offset(skip).limit(limit).all() def get_theater_release(db: Session, release_id: int): return db.query(models.TheaterRelease).filter(models.TheaterRelease.id == release_id).first() def get_upcoming_theater_releases(db: Session, limit: int = 4): from datetime import date, timedelta today = date.today() week_start = today - timedelta(days=3) # Same range as "this week" week_end = today + timedelta(days=7) # First, get releases that are more than 7 days away (true upcoming) upcoming = db.query(models.TheaterRelease).filter( models.TheaterRelease.release_date > week_end ).order_by(models.TheaterRelease.release_date).limit(limit).all() # If we don't have enough upcoming releases, pad with older releases (not in "this week" range) if len(upcoming) < limit: older_start = today - timedelta(days=14) # Look back 2 weeks older_end = week_start # Up to the start of "this week" range older = db.query(models.TheaterRelease).filter( and_( models.TheaterRelease.release_date >= older_start, models.TheaterRelease.release_date < older_end ) ).order_by(models.TheaterRelease.release_date.desc()).limit(limit - len(upcoming)).all() upcoming.extend(older) return upcoming def get_this_week_theater_releases(db: Session, limit: int = 4): from datetime import date, timedelta today = date.today() week_start = today - timedelta(days=3) # Include releases from 3 days ago week_end = today + timedelta(days=7) # Get releases within the range (3 days ago to 7 days ahead) return db.query(models.TheaterRelease).filter( and_( models.TheaterRelease.release_date >= week_start, models.TheaterRelease.release_date <= week_end ) ).order_by(models.TheaterRelease.release_date).limit(limit).all() def create_theater_release(db: Session, release: schemas.TheaterReleaseCreate): db_release = models.TheaterRelease(**release.dict()) db.add(db_release) db.commit() db.refresh(db_release) return db_release def update_theater_release(db: Session, release_id: int, release_update: schemas.TheaterReleaseUpdate): db_release = db.query(models.TheaterRelease).filter(models.TheaterRelease.id == release_id).first() if db_release: update_data = release_update.dict(exclude_unset=True) for key, value in update_data.items(): setattr(db_release, key, value) db.commit() db.refresh(db_release) return db_release def delete_theater_release(db: Session, release_id: int): db_release = db.query(models.TheaterRelease).filter(models.TheaterRelease.id == release_id).first() if db_release: db.delete(db_release) db.commit() return db_release # OTT Release CRUD operations def get_ott_releases(db: Session, skip: int = 0, limit: int = 100): return db.query(models.OTTRelease).order_by(desc(models.OTTRelease.release_date)).offset(skip).limit(limit).all() def get_ott_release(db: Session, release_id: int): return db.query(models.OTTRelease).filter(models.OTTRelease.id == release_id).first() def get_upcoming_ott_releases(db: Session, limit: int = 4): from datetime import date, timedelta today = date.today() week_start = today - timedelta(days=3) # Same range as "this week" week_end = today + timedelta(days=7) # First, get releases that are more than 7 days away (true upcoming) upcoming = db.query(models.OTTRelease).filter( models.OTTRelease.release_date > week_end ).order_by(models.OTTRelease.release_date).limit(limit).all() # If we don't have enough upcoming releases, pad with older releases (not in "this week" range) if len(upcoming) < limit: older_start = today - timedelta(days=14) # Look back 2 weeks older_end = week_start # Up to the start of "this week" range older = db.query(models.OTTRelease).filter( and_( models.OTTRelease.release_date >= older_start, models.OTTRelease.release_date < older_end ) ).order_by(models.OTTRelease.release_date.desc()).limit(limit - len(upcoming)).all() upcoming.extend(older) return upcoming def get_this_week_ott_releases(db: Session, limit: int = 4): from datetime import date, timedelta today = date.today() week_start = today - timedelta(days=3) # Include releases from 3 days ago week_end = today + timedelta(days=7) # Get releases within the range (3 days ago to 7 days ahead) return db.query(models.OTTRelease).filter( and_( models.OTTRelease.release_date >= week_start, models.OTTRelease.release_date <= week_end ) ).order_by(models.OTTRelease.release_date).limit(limit).all() def create_ott_release(db: Session, release: schemas.OTTReleaseCreate): db_release = models.OTTRelease(**release.dict()) db.add(db_release) db.commit() db.refresh(db_release) return db_release def update_ott_release(db: Session, release_id: int, release_update: schemas.OTTReleaseUpdate): db_release = db.query(models.OTTRelease).filter(models.OTTRelease.id == release_id).first() if db_release: update_data = release_update.dict(exclude_unset=True) for key, value in update_data.items(): setattr(db_release, key, value) db.commit() db.refresh(db_release) return db_release def delete_ott_release(db: Session, release_id: int): db_release = db.query(models.OTTRelease).filter(models.OTTRelease.id == release_id).first() if db_release: db.delete(db_release) db.commit() return db_release # Get OTT platforms list def get_ott_platforms(): """Get predefined list of OTT platforms""" return [ "Netflix", "Prime Video", "Disney+ Hotstar", "Zee5", "SonyLiv", "Voot", "ALTBalaji", "MX Player", "Eros Now", "Hoichoi", "Sun NXT", "Aha", "Apple TV+", "YouTube Premium", "Jio Cinema" ]

from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker import os from pathlib import Path ROOT_DIR = Path(__file__).parent DATABASE_URL = f"sqlite:///{ROOT_DIR}/blog_cms.db" engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False}) SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) Base = declarative_base() def get_db(): db = SessionLocal() try: yield db finally: db.close()

#!/usr/bin/env python3 """ Gallery Data Structure Migration Script This script converts the existing gallery image format from: {'id', 'name', 'data', 'size'} (base64 data format) To: {'url', 'alt', 'caption'} (URL-based format expected by frontend) And ensures articles are properly linked to galleries. """ import sqlite3 import json import base64 import os from datetime import datetime def convert_base64_to_placeholder_url(base64_data, image_name, gallery_id, image_index): """Convert base64 image data to placeholder URL format""" # For demo purposes, we'll create placeholder URLs # In production, you'd save the base64 to actual files and create real URLs file_extension = image_name.split('.')[-1] if '.' in image_name else 'jpg' placeholder_url = f"https://picsum.photos/800/600?random={gallery_id}-{image_index}" return { "url": placeholder_url, "alt": f"Image from {gallery_id}", "caption": f"Gallery image: {image_name}" } def migrate_gallery_images(): """Migrate gallery images from base64 format to URL format""" print("🔄 Starting gallery image format migration...") # Connect to database conn = sqlite3.connect('/app/backend/blog_cms.db') cursor = conn.cursor() try: # Get all galleries with image data cursor.execute('SELECT id, gallery_id, title, images FROM galleries WHERE images IS NOT NULL') galleries = cursor.fetchall() print(f"📊 Found {len(galleries)} galleries to migrate") updated_galleries = 0 for gallery in galleries: gallery_db_id, gallery_id, title, images_json = gallery print(f"\n🎨 Processing gallery: {gallery_id} - {title}") try: # Parse existing images old_images = json.loads(images_json) print(f" 📷 Found {len(old_images)} images in old format") # Convert to new format new_images = [] for i, old_image in enumerate(old_images): if isinstance(old_image, dict): # Check if already in new format if 'url' in old_image and 'alt' in old_image: print(f" ✅ Image {i+1} already in new format") new_images.append(old_image) else: # Convert from old format image_name = old_image.get('name', f'image_{i+1}.jpg') base64_data = old_image.get('data', '') new_image = convert_base64_to_placeholder_url( base64_data, image_name, gallery_id, i+1 ) new_images.append(new_image) print(f" 🔄 Converted image {i+1}: {image_name}") else: # Handle unexpected format print(f" ⚠️ Image {i+1} has unexpected format, creating placeholder") new_image = { "url": f"https://picsum.photos/800/600?random={gallery_id}-{i+1}", "alt": f"Gallery image {i+1}", "caption": f"Image {i+1} from {title}" } new_images.append(new_image) # Update database with new format new_images_json = json.dumps(new_images) cursor.execute( 'UPDATE galleries SET images = ?, updated_at = ? WHERE id = ?', (new_images_json, datetime.utcnow(), gallery_db_id) ) updated_galleries += 1 print(f" ✅ Updated gallery {gallery_id} with {len(new_images)} images in new format") except Exception as e: print(f" ❌ Error processing gallery {gallery_id}: {e}") continue # Commit changes conn.commit() print(f"\n🎉 Migration completed! Updated {updated_galleries} galleries") except Exception as e: print(f"❌ Migration failed: {e}") conn.rollback() finally: conn.close() def link_articles_to_galleries(): """Ensure articles are properly linked to galleries""" print("\n🔗 Checking article-gallery links...") conn = sqlite3.connect('/app/backend/blog_cms.db') cursor = conn.cursor() try: # Find travel pics articles that should be linked to galleries cursor.execute(''' SELECT id, title, gallery_id FROM articles WHERE (title LIKE '%Travel Pics%' OR title LIKE '%Gallery%' OR category = 'travel-pics') AND gallery_id IS NOT NULL ''') articles_with_galleries = cursor.fetchall() print(f"📊 Found {len(articles_with_galleries)} articles already linked to galleries:") for article in articles_with_galleries: print(f" 📰 Article {article[0]}: {article[1]} -> Gallery ID {article[2]}") # Get available galleries cursor.execute('SELECT id, gallery_id, title FROM galleries') available_galleries = cursor.fetchall() print(f"\n📊 Available galleries:") for gallery in available_galleries: print(f" 🎨 Gallery DB_ID {gallery[0]}: {gallery[1]} - {gallery[2]}") # Link some test articles to galleries if they aren't already linked if available_galleries: cursor.execute(''' SELECT id, title FROM articles WHERE (title LIKE '%Travel%' OR category LIKE '%travel%' OR category LIKE '%gallery%') AND gallery_id IS NULL LIMIT 3 ''') unlinked_articles = cursor.fetchall() linked_count = 0 for i, article in enumerate(unlinked_articles): if i < len(available_galleries): article_id, article_title = article gallery_db_id = available_galleries[i][0] gallery_title = available_galleries[i][2] cursor.execute( 'UPDATE articles SET gallery_id = ?, updated_at = ? WHERE id = ?', (gallery_db_id, datetime.utcnow(), article_id) ) linked_count += 1 print(f" 🔗 Linked article '{article_title}' to gallery '{gallery_title}'") if linked_count > 0: conn.commit() print(f"✅ Successfully linked {linked_count} articles to galleries") else: print("ℹ️ No additional articles needed linking") except Exception as e: print(f"❌ Error linking articles to galleries: {e}") conn.rollback() finally: conn.close() def verify_migration(): """Verify the migration was successful""" print("\n🔍 Verifying migration results...") conn = sqlite3.connect('/app/backend/blog_cms.db') cursor = conn.cursor() try: # Check gallery image format cursor.execute('SELECT id, gallery_id, title, images FROM galleries LIMIT 3') galleries = cursor.fetchall() print("📊 Gallery verification:") for gallery in galleries: gallery_id, gallery_custom_id, title, images_json = gallery try: images = json.loads(images_json) if images and isinstance(images[0], dict): first_image = images[0] has_url = 'url' in first_image has_alt = 'alt' in first_image has_caption = 'caption' in first_image status = "✅" if (has_url and has_alt and has_caption) else "❌" print(f" {status} Gallery {gallery_custom_id}: {len(images)} images, format: {list(first_image.keys())}") else: print(f" ❌ Gallery {gallery_custom_id}: Invalid image format") except: print(f" ❌ Gallery {gallery_custom_id}: Could not parse images") # Check article-gallery links cursor.execute(''' SELECT a.id, a.title, a.gallery_id, g.gallery_id, g.title FROM articles a LEFT JOIN galleries g ON a.gallery_id = g.id WHERE a.gallery_id IS NOT NULL LIMIT 5 ''') linked_articles = cursor.fetchall() print(f"\n📊 Article-gallery links verification ({len(linked_articles)} found):") for link in linked_articles: article_id, article_title, gallery_db_id, gallery_custom_id, gallery_title = link status = "✅" if gallery_custom_id else "❌" print(f" {status} Article '{article_title}' -> Gallery '{gallery_title}' ({gallery_custom_id})") except Exception as e: print(f"❌ Verification failed: {e}") finally: conn.close() if __name__ == "__main__": print("🚀 Starting Gallery Data Structure Migration") print("=" * 60) # Step 1: Migrate gallery image format migrate_gallery_images() # Step 2: Ensure articles are linked to galleries link_articles_to_galleries() # Step 3: Verify migration verify_migration() print("\n" + "=" * 60) print("✅ Migration completed! Gallery data structure is now compatible with frontend GalleryPost component.") print("\n📋 Next steps:") print(" 1. Restart backend services") print(" 2. Test gallery post functionality") print(" 3. Verify image slider works correctly")

#!/usr/bin/env python3 """ Database migration script to add language columns to theater_releases and ott_releases tables. This migration adds the missing 'language' column to both theater_releases and ott_releases tables that was causing SQLAlchemy errors when trying to create new theater/OTT releases. """ import sqlite3 import os from pathlib import Path from datetime import datetime # Database path ROOT_DIR = Path(__file__).parent DATABASE_PATH = ROOT_DIR / "blog_cms.db" def check_column_exists(cursor, table_name, column_name): """Check if a column exists in a table""" cursor.execute(f"PRAGMA table_info({table_name})") columns = cursor.fetchall() column_names = [column[1] for column in columns] return column_name in column_names def add_language_column_if_missing(cursor, table_name): """Add language column to table if it doesn't exist""" if not check_column_exists(cursor, table_name, 'language'): print(f"Adding 'language' column to {table_name} table...") cursor.execute(f"ALTER TABLE {table_name} ADD COLUMN language TEXT DEFAULT 'Hindi'") print(f"✅ Successfully added 'language' column to {table_name}") return True else: print(f"ℹ️ Column 'language' already exists in {table_name}") return False def check_table_exists(cursor, table_name): """Check if a table exists in the database""" cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?", (table_name,)) return cursor.fetchone() is not None def main(): """Main migration function""" print("=" * 60) print("DATABASE MIGRATION: Adding language columns") print("=" * 60) if not DATABASE_PATH.exists(): print(f"❌ Database file not found at {DATABASE_PATH}") print("Please ensure the backend has been started at least once to create the database.") return False try: # Connect to database conn = sqlite3.connect(DATABASE_PATH) cursor = conn.cursor() # Check if tables exist tables_to_migrate = ['theater_releases', 'ott_releases'] migrations_applied = [] for table_name in tables_to_migrate: if check_table_exists(cursor, table_name): print(f"📋 Found table: {table_name}") if add_language_column_if_missing(cursor, table_name): migrations_applied.append(table_name) else: print(f"⚠️ Table {table_name} does not exist. It will be created when the server starts.") # Commit changes conn.commit() # Verify the migration print("\n" + "=" * 40) print("MIGRATION VERIFICATION") print("=" * 40) for table_name in tables_to_migrate: if check_table_exists(cursor, table_name): cursor.execute(f"PRAGMA table_info({table_name})") columns = cursor.fetchall() print(f"\n📊 {table_name} table structure:") for column in columns: column_name = column[1] column_type = column[2] column_default = column[4] if column[4] else "None" status = "✅" if column_name == 'language' else " " print(f" {status} {column_name} ({column_type}) - Default: {column_default}") conn.close() print("\n" + "=" * 60) if migrations_applied: print(f"✅ MIGRATION COMPLETED SUCCESSFULLY!") print(f"📝 Applied migrations to: {', '.join(migrations_applied)}") print("🎯 Theater and OTT release creation should now work correctly.") else: print("ℹ️ NO MIGRATIONS NEEDED - All columns already exist.") print("=" * 60) return True except sqlite3.Error as e: print(f"❌ Database error: {e}") return False except Exception as e: print(f"❌ Unexpected error: {e}") return False if __name__ == "__main__": success = main() exit(0 if success else 1)

# Import all database models from .database_models import Category, Article, MovieReview, FeaturedImage, SchedulerSettings, RelatedArticlesConfig, TheaterRelease, OTTRelease, Gallery, Topic # Import all auth models from .auth_models import RegisterRequest, LoginRequest, Token, UserResponse, UserInDB # Expose all models at the package level __all__ = [ 'Category', 'Article', 'MovieReview', 'FeaturedImage', 'SchedulerSettings', 'RelatedArticlesConfig', 'TheaterRelease', 'OTTRelease', 'Gallery', 'Topic', 'RegisterRequest', 'LoginRequest', 'Token', 'UserResponse', 'UserInDB' ]

from pydantic import BaseModel from typing import List, Optional from datetime import datetime class RegisterRequest(BaseModel): username: str password: str confirm_password: str class LoginRequest(BaseModel): username: str password: str class Token(BaseModel): access_token: str token_type: str user: "UserResponse" class UserResponse(BaseModel): username: str roles: List[str] is_active: bool created_at: Optional[datetime] = None class UserInDB(BaseModel): username: str hashed_password: str roles: List[str] is_active: bool created_at: Optional[datetime] = None

from sqlalchemy import Column, Integer, String, Text, DateTime, Boolean, Float, Date, ForeignKey, Table from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import relationship from datetime import datetime from database import Base # Association table for many-to-many relationship between articles and topics article_topic_association = Table( 'article_topics', Base.metadata, Column('article_id', Integer, ForeignKey('articles.id'), primary_key=True), Column('topic_id', Integer, ForeignKey('topics.id'), primary_key=True) ) # Association table for many-to-many relationship between galleries and topics gallery_topic_association = Table( 'gallery_topics', Base.metadata, Column('gallery_id', Integer, ForeignKey('galleries.id'), primary_key=True), Column('topic_id', Integer, ForeignKey('topics.id'), primary_key=True) ) class Category(Base): __tablename__ = "categories" id = Column(Integer, primary_key=True, index=True) name = Column(String, unique=True, index=True) slug = Column(String, unique=True, index=True) description = Column(Text) created_at = Column(DateTime, default=datetime.utcnow) class Article(Base): __tablename__ = "articles" id = Column(Integer, primary_key=True, index=True) title = Column(String, index=True) short_title = Column(String) # New field for short title slug = Column(String, unique=True, index=True) content = Column(Text) summary = Column(String) author = Column(String) language = Column(String, default="en") # New field for language support states = Column(Text) # JSON string for supported states category = Column(String, index=True) content_type = Column(String, default='post') # New field for content type (post, photo, video, movie_review) image = Column(String) image_gallery = Column(Text) # New field for image gallery (JSON string array) gallery_id = Column(Integer, ForeignKey('galleries.id')) # Reference to Gallery table youtube_url = Column(String) # New field for YouTube links tags = Column(String) artists = Column(Text) # New field for artists (JSON string array) movie_rating = Column(String) # New field for movie rating (0-5 with 0.25 increments) is_featured = Column(Boolean, default=False) is_published = Column(Boolean, default=True) # New field for draft/published status is_scheduled = Column(Boolean, default=False) # New field for scheduled posts scheduled_publish_at = Column(DateTime) # New field for scheduled publish date/time (IST) original_article_id = Column(Integer) # For linking translated articles seo_title = Column(String) # New field for SEO optimization seo_description = Column(String) # New field for SEO meta description seo_keywords = Column(String) # New field for SEO keywords view_count = Column(Integer, default=0) created_at = Column(DateTime, default=datetime.utcnow) updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow) published_at = Column(DateTime) # Many-to-many relationship with topics topics = relationship("Topic", secondary=article_topic_association, back_populates="articles") # Relationship with Gallery gallery = relationship("Gallery", foreign_keys=[gallery_id]) class SchedulerSettings(Base): __tablename__ = "scheduler_settings" id = Column(Integer, primary_key=True, index=True) is_enabled = Column(Boolean, default=False) # Admin can enable/disable scheduler check_frequency_minutes = Column(Integer, default=5) # Check every 5 minutes by default created_at = Column(DateTime, default=datetime.utcnow) updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow) class RelatedArticlesConfig(Base): __tablename__ = "related_articles_config" id = Column(Integer, primary_key=True, index=True) page_slug = Column(String, unique=True, index=True) # e.g., 'latest-news', 'politics', etc. categories = Column(Text) # JSON string array of category slugs article_count = Column(Integer, default=5) # Number of articles to show created_at = Column(DateTime, default=datetime.utcnow) updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow) class MovieReview(Base): __tablename__ = "movie_reviews" id = Column(Integer, primary_key=True, index=True) title = Column(String, index=True) movie_name = Column(String, index=True) director = Column(String) cast = Column(Text) genre = Column(String) rating = Column(Float) review_content = Column(Text) reviewer = Column(String) published_at = Column(DateTime, default=datetime.utcnow) poster_image = Column(String) view_count = Column(Integer, default=0) created_at = Column(DateTime, default=datetime.utcnow) class FeaturedImage(Base): __tablename__ = "featured_images" id = Column(Integer, primary_key=True, index=True) title = Column(String, index=True) image_url = Column(String) caption = Column(Text) photographer = Column(String) location = Column(String) is_active = Column(Boolean, default=True) display_order = Column(Integer, default=0) created_at = Column(DateTime, default=datetime.utcnow) class TheaterRelease(Base): __tablename__ = "theater_releases" id = Column(Integer, primary_key=True, index=True) movie_name = Column(String, index=True, nullable=False) movie_banner = Column(String) # Text field, not file path movie_image = Column(String) # Path to uploaded movie image language = Column(String, default="Hindi") # Movie language release_date = Column(Date, nullable=False) created_by = Column(String) # User who created this entry created_at = Column(DateTime, default=datetime.utcnow) updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow) class OTTRelease(Base): __tablename__ = "ott_releases" id = Column(Integer, primary_key=True, index=True) movie_name = Column(String, index=True, nullable=False) ott_platform = Column(String, nullable=False) # Netflix, Prime Video, etc. movie_image = Column(String) # Path to uploaded movie image language = Column(String, default="Hindi") # Movie language release_date = Column(Date, nullable=False) created_by = Column(String) # User who created this entry created_at = Column(DateTime, default=datetime.utcnow) updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow) class Topic(Base): __tablename__ = "topics" id = Column(Integer, primary_key=True, index=True) title = Column(String, index=True, nullable=False) slug = Column(String, unique=True, index=True, nullable=False) description = Column(Text) category = Column(String, index=True, nullable=False) # Movies, Politics, Sports, TV, Travel image = Column(String) # Path to uploaded topic image language = Column(String, default="en") created_at = Column(DateTime, default=datetime.utcnow) updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow) # Many-to-many relationship with articles articles = relationship("Article", secondary=article_topic_association, back_populates="topics") # Many-to-many relationship with galleries galleries = relationship("Gallery", secondary=gallery_topic_association, back_populates="topics") class TopicCategory(Base): __tablename__ = "topic_categories" id = Column(Integer, primary_key=True, index=True) name = Column(String, unique=True, index=True, nullable=False) slug = Column(String, unique=True, index=True, nullable=False) created_at = Column(DateTime, default=datetime.utcnow) class Gallery(Base): __tablename__ = "galleries" id = Column(Integer, primary_key=True, index=True) gallery_id = Column(String, unique=True, index=True, nullable=False) # Custom ID like VIG-timestamp-suffix title = Column(String, index=True, nullable=False) artists = Column(Text) # JSON string array of artist names images = Column(Text, nullable=False) # JSON string array of image data gallery_type = Column(String, default="vertical") # vertical or horizontal created_at = Column(DateTime, default=datetime.utcnow) updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow) # Many-to-many relationship with topics topics = relationship("Topic", secondary=gallery_topic_association, back_populates="galleries")

#!/usr/bin/env python3 """Script to rename 'Sports' category to 'Other Sports' in the database""" import os import sys sys.path.append('/app/backend') from database import SessionLocal import models def rename_sports_category(): """Rename the Sports category to Other Sports""" db = SessionLocal() try: # Find the Sports category (ID 4, slug: "sports") sports_category = db.query(models.Category).filter(models.Category.slug == "sports").first() if sports_category: print(f"Found Sports category: {sports_category.name} (ID: {sports_category.id}, slug: {sports_category.slug})") # Update the category name and slug sports_category.name = "Other Sports" sports_category.slug = "other-sports" sports_category.description = "Other sports news and updates beyond cricket" db.commit() print(f"✅ Successfully updated category to: {sports_category.name} (slug: {sports_category.slug})") # Also update any articles that use this category articles_updated = db.query(models.Article).filter(models.Article.category == "sports").update( {"category": "other-sports"} ) db.commit() print(f"✅ Updated {articles_updated} articles to use 'other-sports' category slug") else: print("❌ Sports category not found") except Exception as e: print(f"❌ Error: {e}") db.rollback() finally: db.close() if __name__ == "__main__": rename_sports_category()

fastapi==0.110.1 uvicorn==0.25.0 sqlalchemy>=2.0.0 python-dotenv>=1.0.1 pydantic>=2.6.4 email-validator>=2.2.0 tzdata>=2024.2 pytest>=8.0.0 requests>=2.31.0 python-multipart>=0.0.9 typer>=0.9.0 alembic>=1.13.0 motor==3.3.2 pymongo==4.6.1 python-jose[cryptography]==3.3.0 passlib[bcrypt]==1.7.4 bcrypt==4.1.2 apscheduler==3.10.4 pytz==2024.1 aiofiles==23.2.1

from fastapi import APIRouter, Depends, HTTPException, status from fastapi.security import OAuth2PasswordRequestForm from datetime import datetime, timedelta from models.auth_models import RegisterRequest, LoginRequest, Token, UserResponse from auth import ( authenticate_user, create_access_token, get_password_hash, users_collection, get_current_active_user, require_admin, ACCESS_TOKEN_EXPIRE_MINUTES ) router = APIRouter(prefix="/api/auth", tags=["Authentication"]) @router.post("/register", response_model=dict) async def register_user(user_data: RegisterRequest): """Register a new user""" # Check if passwords match if user_data.password != user_data.confirm_password: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="Passwords do not match" ) # Check if username already exists existing_user = await users_collection.find_one({"username": user_data.username}) if existing_user: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="Username already registered" ) # Create new user hashed_password = get_password_hash(user_data.password) user_doc = { "username": user_data.username, "hashed_password": hashed_password, "password": user_data.password, # Keep for model compatibility "roles": ["Viewer"], # Default role "created_at": datetime.utcnow(), "is_active": True } result = await users_collection.insert_one(user_doc) if result.inserted_id: return { "message": "User registered successfully", "username": user_data.username, "roles": ["Viewer"] } raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to create user" ) @router.post("/login", response_model=Token) async def login(form_data: OAuth2PasswordRequestForm = Depends()): """Login user and return JWT token""" user = await authenticate_user(form_data.username, form_data.password) if not user: raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="Incorrect username or password", headers={"WWW-Authenticate": "Bearer"}, ) access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) access_token = create_access_token( data={"sub": user.username, "roles": user.roles}, expires_delta=access_token_expires ) return { "access_token": access_token, "token_type": "bearer", "user": UserResponse( username=user.username, roles=user.roles, created_at=user.created_at, is_active=user.is_active ) } @router.get("/me", response_model=UserResponse) async def get_current_user_info(current_user: UserResponse = Depends(get_current_active_user)): """Get current user information""" return current_user @router.get("/users", response_model=list) async def get_all_users(current_user: UserResponse = Depends(require_admin)): """Get all users (Admin only)""" users = [] async for user in users_collection.find({}, {"hashed_password": 0, "password": 0}): user["_id"] = str(user["_id"]) users.append(user) return users @router.put("/users/{username}/role") async def update_user_role( username: str, new_roles: list, current_user: UserResponse = Depends(require_admin) ): """Update user roles (Admin only)""" valid_roles = ["Viewer", "Author", "Publisher", "Admin"] if not all(role in valid_roles for role in new_roles): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid role specified" ) result = await users_collection.update_one( {"username": username}, {"$set": {"roles": new_roles}} ) if result.matched_count == 0: raise HTTPException( status_code=status.HTTP_404_NOT_FOUND, detail="User not found" ) return {"message": f"User {username} roles updated to {new_roles}"} @router.delete("/users/{username}") async def delete_user( username: str, current_user: UserResponse = Depends(require_admin) ): """Delete user (Admin only)""" if username == "admin": raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="Cannot delete admin user" ) result = await users_collection.delete_one({"username": username}) if result.deleted_count == 0: raise HTTPException( status_code=status.HTTP_404_NOT_FOUND, detail="User not found" ) return {"message": f"User {username} deleted successfully"}

from fastapi import APIRouter, Depends, HTTPException, status from sqlalchemy.orm import Session from sqlalchemy import desc from typing import List, Optional from datetime import datetime from pydantic import BaseModel import json from database import get_db from models.database_models import Gallery router = APIRouter() class GalleryCreate(BaseModel): gallery_id: str title: str artists: List[str] images: List[dict] # List of image objects with id, name, data, size gallery_type: Optional[str] = "vertical" class GalleryUpdate(BaseModel): title: Optional[str] = None artists: Optional[List[str]] = None images: Optional[List[dict]] = None gallery_type: Optional[str] = None class GalleryResponse(BaseModel): id: int gallery_id: str title: str artists: List[str] images: List[dict] gallery_type: str created_at: datetime updated_at: datetime class Config: from_attributes = True @router.post("/galleries", response_model=GalleryResponse) async def create_gallery(gallery: GalleryCreate, db: Session = Depends(get_db)): """Create a new gallery""" # Check if gallery_id already exists existing_gallery = db.query(Gallery).filter(Gallery.gallery_id == gallery.gallery_id).first() if existing_gallery: raise HTTPException(status_code=400, detail="Gallery ID already exists") # Create new gallery db_gallery = Gallery( gallery_id=gallery.gallery_id, title=gallery.title, artists=json.dumps(gallery.artists), images=json.dumps(gallery.images), gallery_type=gallery.gallery_type ) db.add(db_gallery) db.commit() db.refresh(db_gallery) # Format response return GalleryResponse( id=db_gallery.id, gallery_id=db_gallery.gallery_id, title=db_gallery.title, artists=json.loads(db_gallery.artists), images=json.loads(db_gallery.images), gallery_type=db_gallery.gallery_type, created_at=db_gallery.created_at, updated_at=db_gallery.updated_at ) @router.get("/galleries", response_model=List[GalleryResponse]) async def get_galleries(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)): """Get all galleries""" galleries = db.query(Gallery).order_by(desc(Gallery.created_at)).offset(skip).limit(limit).all() result = [] for gallery in galleries: result.append(GalleryResponse( id=gallery.id, gallery_id=gallery.gallery_id, title=gallery.title, artists=json.loads(gallery.artists) if gallery.artists else [], images=json.loads(gallery.images) if gallery.images else [], gallery_type=gallery.gallery_type, created_at=gallery.created_at, updated_at=gallery.updated_at )) return result @router.get("/galleries/{gallery_id}", response_model=GalleryResponse) async def get_gallery(gallery_id: str, db: Session = Depends(get_db)): """Get a specific gallery by gallery_id""" gallery = db.query(Gallery).filter(Gallery.gallery_id == gallery_id).first() if not gallery: raise HTTPException(status_code=404, detail="Gallery not found") return GalleryResponse( id=gallery.id, gallery_id=gallery.gallery_id, title=gallery.title, artists=json.loads(gallery.artists) if gallery.artists else [], images=json.loads(gallery.images) if gallery.images else [], gallery_type=gallery.gallery_type, created_at=gallery.created_at, updated_at=gallery.updated_at ) @router.get("/galleries/by-id/{id}", response_model=GalleryResponse) async def get_gallery_by_id(id: int, db: Session = Depends(get_db)): """Get a specific gallery by numeric ID""" gallery = db.query(Gallery).filter(Gallery.id == id).first() if not gallery: raise HTTPException(status_code=404, detail="Gallery not found") return GalleryResponse( id=gallery.id, gallery_id=gallery.gallery_id, title=gallery.title, artists=json.loads(gallery.artists) if gallery.artists else [], images=json.loads(gallery.images) if gallery.images else [], gallery_type=gallery.gallery_type, created_at=gallery.created_at, updated_at=gallery.updated_at ) @router.put("/galleries/{gallery_id}", response_model=GalleryResponse) async def update_gallery(gallery_id: str, gallery_update: GalleryUpdate, db: Session = Depends(get_db)): """Update a gallery""" gallery = db.query(Gallery).filter(Gallery.gallery_id == gallery_id).first() if not gallery: raise HTTPException(status_code=404, detail="Gallery not found") # Update fields if provided if gallery_update.title is not None: gallery.title = gallery_update.title if gallery_update.artists is not None: gallery.artists = json.dumps(gallery_update.artists) if gallery_update.images is not None: gallery.images = json.dumps(gallery_update.images) if gallery_update.gallery_type is not None: gallery.gallery_type = gallery_update.gallery_type gallery.updated_at = datetime.utcnow() db.commit() db.refresh(gallery) return GalleryResponse( id=gallery.id, gallery_id=gallery.gallery_id, title=gallery.title, artists=json.loads(gallery.artists) if gallery.artists else [], images=json.loads(gallery.images) if gallery.images else [], gallery_type=gallery.gallery_type, created_at=gallery.created_at, updated_at=gallery.updated_at ) @router.delete("/galleries/{gallery_id}") async def delete_gallery(gallery_id: str, db: Session = Depends(get_db)): """Delete a gallery""" gallery = db.query(Gallery).filter(Gallery.gallery_id == gallery_id).first() if not gallery: raise HTTPException(status_code=404, detail="Gallery not found") db.delete(gallery) db.commit() return {"message": "Gallery deleted successfully"}

from fastapi import APIRouter, Depends, HTTPException, status, UploadFile, File from sqlalchemy.orm import Session from sqlalchemy import and_, or_, desc, asc from typing import List, Optional import shutil import os import uuid from datetime import datetime from pydantic import BaseModel import re from database import get_db from models.database_models import Topic, TopicCategory, Article, article_topic_association, Gallery, gallery_topic_association router = APIRouter() class TopicCreate(BaseModel): title: str description: Optional[str] = None category: str language: Optional[str] = "en" class TopicUpdate(BaseModel): title: Optional[str] = None description: Optional[str] = None category: Optional[str] = None language: Optional[str] = None class TopicResponse(BaseModel): id: int title: str slug: str description: Optional[str] category: str image: Optional[str] language: str created_at: datetime updated_at: datetime articles_count: Optional[int] = 0 class Config: from_attributes = True class TopicCategoryCreate(BaseModel): name: str class TopicCategoryResponse(BaseModel): id: int name: str slug: str created_at: datetime class Config: from_attributes = True def create_slug(title: str) -> str: """Create a URL-friendly slug from title""" slug = re.sub(r'[^a-zA-Z0-9\s-]', '', title) slug = re.sub(r'\s+', '-', slug.strip()) return slug.lower() # Get all topics with filtering @router.get("/topics", response_model=List[TopicResponse]) async def get_topics( category: Optional[str] = None, language: Optional[str] = None, search: Optional[str] = None, skip: int = 0, limit: int = 100, db: Session = Depends(get_db) ): """Get all topics with optional filtering""" query = db.query(Topic) # Apply filters if category: query = query.filter(Topic.category == category) if language: query = query.filter(Topic.language == language) if search: query = query.filter( or_( Topic.title.ilike(f"%{search}%"), Topic.description.ilike(f"%{search}%") ) ) # Order by created_at desc and apply pagination topics = query.order_by(desc(Topic.created_at)).offset(skip).limit(limit).all() # Add article count for each topic result = [] for topic in topics: articles_count = db.query(article_topic_association).filter( article_topic_association.c.topic_id == topic.id ).count() topic_dict = { "id": topic.id, "title": topic.title, "slug": topic.slug, "description": topic.description, "category": topic.category, "image": topic.image, "language": topic.language, "created_at": topic.created_at, "updated_at": topic.updated_at, "articles_count": articles_count } result.append(TopicResponse(**topic_dict)) return result # Get single topic by ID @router.get("/topics/{topic_id}", response_model=TopicResponse) async def get_topic(topic_id: int, db: Session = Depends(get_db)): """Get single topic by ID""" topic = db.query(Topic).filter(Topic.id == topic_id).first() if not topic: raise HTTPException(status_code=404, detail="Topic not found") # Get articles count articles_count = db.query(article_topic_association).filter( article_topic_association.c.topic_id == topic.id ).count() topic_dict = { "id": topic.id, "title": topic.title, "slug": topic.slug, "description": topic.description, "category": topic.category, "image": topic.image, "language": topic.language, "created_at": topic.created_at, "updated_at": topic.updated_at, "articles_count": articles_count } return TopicResponse(**topic_dict) # Get topic by slug @router.get("/topics/slug/{topic_slug}", response_model=TopicResponse) async def get_topic_by_slug(topic_slug: str, db: Session = Depends(get_db)): """Get topic by slug""" topic = db.query(Topic).filter(Topic.slug == topic_slug).first() if not topic: raise HTTPException(status_code=404, detail="Topic not found") # Get articles count articles_count = db.query(article_topic_association).filter( article_topic_association.c.topic_id == topic.id ).count() topic_dict = { "id": topic.id, "title": topic.title, "slug": topic.slug, "description": topic.description, "category": topic.category, "image": topic.image, "language": topic.language, "created_at": topic.created_at, "updated_at": topic.updated_at, "articles_count": articles_count } return TopicResponse(**topic_dict) # Create new topic @router.post("/topics", response_model=TopicResponse) async def create_topic( topic_data: TopicCreate, db: Session = Depends(get_db) ): """Create a new topic""" # Create slug from title base_slug = create_slug(topic_data.title) slug = base_slug # Ensure unique slug counter = 1 while db.query(Topic).filter(Topic.slug == slug).first(): slug = f"{base_slug}-{counter}" counter += 1 # Create topic db_topic = Topic( title=topic_data.title, slug=slug, description=topic_data.description, category=topic_data.category, language=topic_data.language ) db.add(db_topic) db.commit() db.refresh(db_topic) topic_dict = { "id": db_topic.id, "title": db_topic.title, "slug": db_topic.slug, "description": db_topic.description, "category": db_topic.category, "image": db_topic.image, "language": db_topic.language, "created_at": db_topic.created_at, "updated_at": db_topic.updated_at, "articles_count": 0 } return TopicResponse(**topic_dict) # Update topic @router.put("/topics/{topic_id}", response_model=TopicResponse) async def update_topic( topic_id: int, topic_data: TopicUpdate, db: Session = Depends(get_db) ): """Update an existing topic""" db_topic = db.query(Topic).filter(Topic.id == topic_id).first() if not db_topic: raise HTTPException(status_code=404, detail="Topic not found") # Update fields if topic_data.title is not None: db_topic.title = topic_data.title # Update slug if title changed new_slug = create_slug(topic_data.title) if new_slug != db_topic.slug: slug = new_slug counter = 1 while db.query(Topic).filter(Topic.slug == slug, Topic.id != topic_id).first(): slug = f"{new_slug}-{counter}" counter += 1 db_topic.slug = slug if topic_data.description is not None: db_topic.description = topic_data.description if topic_data.category is not None: db_topic.category = topic_data.category if topic_data.language is not None: db_topic.language = topic_data.language db_topic.updated_at = datetime.utcnow() db.commit() db.refresh(db_topic) # Get articles count articles_count = db.query(article_topic_association).filter( article_topic_association.c.topic_id == db_topic.id ).count() topic_dict = { "id": db_topic.id, "title": db_topic.title, "slug": db_topic.slug, "description": db_topic.description, "category": db_topic.category, "image": db_topic.image, "language": db_topic.language, "created_at": db_topic.created_at, "updated_at": db_topic.updated_at, "articles_count": articles_count } return TopicResponse(**topic_dict) # Delete topic @router.delete("/topics/{topic_id}") async def delete_topic(topic_id: int, db: Session = Depends(get_db)): """Delete a topic""" db_topic = db.query(Topic).filter(Topic.id == topic_id).first() if not db_topic: raise HTTPException(status_code=404, detail="Topic not found") # Remove all article associations db.execute( article_topic_association.delete().where( article_topic_association.c.topic_id == topic_id ) ) # Delete topic image if exists if db_topic.image: try: image_path = f"/app/backend/uploads/{db_topic.image}" if os.path.exists(image_path): os.remove(image_path) except Exception as e: print(f"Warning: Could not delete topic image: {e}") # Delete topic db.delete(db_topic) db.commit() return {"message": "Topic deleted successfully"} # Upload topic image @router.post("/topics/{topic_id}/upload-image") async def upload_topic_image( topic_id: int, file: UploadFile = File(...), db: Session = Depends(get_db) ): """Upload image for a topic""" db_topic = db.query(Topic).filter(Topic.id == topic_id).first() if not db_topic: raise HTTPException(status_code=404, detail="Topic not found") # Validate file type if not file.content_type.startswith("image/"): raise HTTPException(status_code=400, detail="File must be an image") # Create uploads directory if it doesn't exist os.makedirs("/app/backend/uploads", exist_ok=True) # Generate unique filename file_extension = file.filename.split(".")[-1] if "." in file.filename else "jpg" filename = f"topic_{topic_id}_{uuid.uuid4()}.{file_extension}" file_path = f"/app/backend/uploads/{filename}" # Save file try: with open(file_path, "wb") as buffer: shutil.copyfileobj(file.file, buffer) except Exception as e: raise HTTPException(status_code=500, detail=f"Could not save file: {e}") # Delete old image if exists if db_topic.image: try: old_image_path = f"/app/backend/uploads/{db_topic.image}" if os.path.exists(old_image_path): os.remove(old_image_path) except Exception as e: print(f"Warning: Could not delete old topic image: {e}") # Update topic with new image path db_topic.image = filename db_topic.updated_at = datetime.utcnow() db.commit() db.refresh(db_topic) return {"message": "Image uploaded successfully", "image": filename} # Get topic categories @router.get("/topic-categories", response_model=List[TopicCategoryResponse]) async def get_topic_categories(db: Session = Depends(get_db)): """Get all topic categories""" categories = db.query(TopicCategory).order_by(TopicCategory.name).all() return categories # Create topic category @router.post("/topic-categories", response_model=TopicCategoryResponse) async def create_topic_category( category_data: TopicCategoryCreate, db: Session = Depends(get_db) ): """Create a new topic category""" # Create slug from name slug = create_slug(category_data.name) # Check if category already exists existing = db.query(TopicCategory).filter( or_( TopicCategory.name == category_data.name, TopicCategory.slug == slug ) ).first() if existing: raise HTTPException(status_code=400, detail="Category already exists") # Create category db_category = TopicCategory( name=category_data.name, slug=slug ) db.add(db_category) db.commit() db.refresh(db_category) return db_category # Get articles for a topic @router.get("/topics/{topic_id}/articles") async def get_topic_articles( topic_id: int, skip: int = 0, limit: int = 50, db: Session = Depends(get_db) ): """Get all articles associated with a topic""" # Verify topic exists topic = db.query(Topic).filter(Topic.id == topic_id).first() if not topic: raise HTTPException(status_code=404, detail="Topic not found") # Get articles through association table articles = db.query(Article).join( article_topic_association, Article.id == article_topic_association.c.article_id ).filter( article_topic_association.c.topic_id == topic_id ).order_by(desc(Article.created_at)).offset(skip).limit(limit).all() return articles # Associate article with topic @router.post("/topics/{topic_id}/articles/{article_id}") async def associate_article_with_topic( topic_id: int, article_id: int, db: Session = Depends(get_db) ): """Associate an article with a topic""" # Verify topic and article exist topic = db.query(Topic).filter(Topic.id == topic_id).first() if not topic: raise HTTPException(status_code=404, detail="Topic not found") article = db.query(Article).filter(Article.id == article_id).first() if not article: raise HTTPException(status_code=404, detail="Article not found") # Check if association already exists existing = db.execute( article_topic_association.select().where( and_( article_topic_association.c.article_id == article_id, article_topic_association.c.topic_id == topic_id ) ) ).first() if existing: raise HTTPException(status_code=400, detail="Association already exists") # Create association db.execute( article_topic_association.insert().values( article_id=article_id, topic_id=topic_id ) ) db.commit() return {"message": "Article associated with topic successfully"} # Remove article from topic @router.delete("/topics/{topic_id}/articles/{article_id}") async def remove_article_from_topic( topic_id: int, article_id: int, db: Session = Depends(get_db) ): """Remove association between article and topic""" # Remove association result = db.execute( article_topic_association.delete().where( and_( article_topic_association.c.article_id == article_id, article_topic_association.c.topic_id == topic_id ) ) ) if result.rowcount == 0: raise HTTPException(status_code=404, detail="Association not found") db.commit() return {"message": "Article removed from topic successfully"} # Get topics for a specific article @router.get("/articles/{article_id}/topics", response_model=List[TopicResponse]) async def get_article_topics( article_id: int, db: Session = Depends(get_db) ): """Get all topics associated with an article""" # Verify article exists article = db.query(Article).filter(Article.id == article_id).first() if not article: raise HTTPException(status_code=404, detail="Article not found") # Get topics through association table topics = db.query(Topic).join( article_topic_association, Topic.id == article_topic_association.c.topic_id ).filter( article_topic_association.c.article_id == article_id ).order_by(Topic.title).all() # Format response with articles count for each topic result = [] for topic in topics: articles_count = db.query(article_topic_association).filter( article_topic_association.c.topic_id == topic.id ).count() topic_dict = { "id": topic.id, "title": topic.title, "slug": topic.slug, "description": topic.description, "category": topic.category, "image": topic.image, "language": topic.language, "created_at": topic.created_at, "updated_at": topic.updated_at, "articles_count": articles_count } result.append(TopicResponse(**topic_dict)) return result # Gallery-Topic Association Endpoints @router.post("/topics/{topic_id}/galleries/{gallery_id}") async def associate_topic_with_gallery( topic_id: int, gallery_id: int, db: Session = Depends(get_db) ): """Associate a topic with a gallery""" # Verify topic exists topic = db.query(Topic).filter(Topic.id == topic_id).first() if not topic: raise HTTPException(status_code=404, detail="Topic not found") # Verify gallery exists gallery = db.query(Gallery).filter(Gallery.id == gallery_id).first() if not gallery: raise HTTPException(status_code=404, detail="Gallery not found") # Check if association already exists existing_association = db.query(gallery_topic_association).filter( and_( gallery_topic_association.c.gallery_id == gallery_id, gallery_topic_association.c.topic_id == topic_id ) ).first() if existing_association: raise HTTPException(status_code=400, detail="Topic is already associated with this gallery") # Create association stmt = gallery_topic_association.insert().values( gallery_id=gallery_id, topic_id=topic_id ) db.execute(stmt) db.commit() return {"message": "Topic successfully associated with gallery"} @router.delete("/topics/{topic_id}/galleries/{gallery_id}") async def disassociate_topic_from_gallery( topic_id: int, gallery_id: int, db: Session = Depends(get_db) ): """Remove association between a topic and a gallery""" # Verify topic exists topic = db.query(Topic).filter(Topic.id == topic_id).first() if not topic: raise HTTPException(status_code=404, detail="Topic not found") # Verify gallery exists gallery = db.query(Gallery).filter(Gallery.id == gallery_id).first() if not gallery: raise HTTPException(status_code=404, detail="Gallery not found") # Check if association exists existing_association = db.query(gallery_topic_association).filter( and_( gallery_topic_association.c.gallery_id == gallery_id, gallery_topic_association.c.topic_id == topic_id ) ).first() if not existing_association: raise HTTPException(status_code=404, detail="Association not found") # Remove association stmt = gallery_topic_association.delete().where( and_( gallery_topic_association.c.gallery_id == gallery_id, gallery_topic_association.c.topic_id == topic_id ) ) db.execute(stmt) db.commit() return {"message": "Topic association removed from gallery"} @router.get("/galleries/{gallery_id}/topics", response_model=List[TopicResponse]) async def get_gallery_topics(gallery_id: int, db: Session = Depends(get_db)): """Get all topics associated with a gallery""" # Verify gallery exists gallery = db.query(Gallery).filter(Gallery.id == gallery_id).first() if not gallery: raise HTTPException(status_code=404, detail="Gallery not found") # Get topics through association table topics = db.query(Topic).join( gallery_topic_association, Topic.id == gallery_topic_association.c.topic_id ).filter( gallery_topic_association.c.gallery_id == gallery_id ).order_by(Topic.title).all() # Format response with articles count for each topic result = [] for topic in topics: articles_count = db.query(article_topic_association).filter( article_topic_association.c.topic_id == topic.id ).count() topic_dict = { "id": topic.id, "title": topic.title, "slug": topic.slug, "description": topic.description, "category": topic.category, "image": topic.image, "language": topic.language, "created_at": topic.created_at, "updated_at": topic.updated_at, "articles_count": articles_count } result.append(TopicResponse(**topic_dict)) return result @router.get("/topics/{topic_id}/galleries") async def get_topic_galleries(topic_id: int, db: Session = Depends(get_db)): """Get all galleries associated with a topic""" # Verify topic exists topic = db.query(Topic).filter(Topic.id == topic_id).first() if not topic: raise HTTPException(status_code=404, detail="Topic not found") # Get galleries through association table with JSON parsing galleries = db.query(Gallery).join( gallery_topic_association, Gallery.id == gallery_topic_association.c.gallery_id ).filter( gallery_topic_association.c.topic_id == topic_id ).order_by(Gallery.created_at.desc()).all() # Format response to match frontend expectations result = [] for gallery in galleries: import json # Parse JSON fields artists = json.loads(gallery.artists) if gallery.artists else [] images = json.loads(gallery.images) if gallery.images else [] gallery_dict = { "id": gallery.id, "gallery_id": gallery.gallery_id, "title": gallery.title, "artists": artists, "images": images, "gallery_type": gallery.gallery_type, "created_at": gallery.created_at, "updated_at": gallery.updated_at } result.append(gallery_dict) return result

import logging from datetime import datetime from apscheduler.schedulers.background import BackgroundScheduler from apscheduler.triggers.interval import IntervalTrigger from pytz import timezone from sqlalchemy.orm import Session from database import SessionLocal import crud import schemas from models.database_models import SchedulerSettings # Configure logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) class ArticleSchedulerService: def __init__(self): self.scheduler = BackgroundScheduler() self.job_id = "publish_scheduled_articles" self.ist = timezone('Asia/Kolkata') def check_and_publish_scheduled_articles(self): """Check for scheduled articles that need to be published""" db: Session = SessionLocal() try: # Get scheduler settings settings = crud.get_scheduler_settings(db) # If scheduler is disabled, return if not settings or not settings.is_enabled: logger.info("Scheduler is disabled, skipping scheduled article check") return # Get articles ready for publishing scheduled_articles = crud.get_scheduled_articles_for_publishing(db) if not scheduled_articles: logger.info("No scheduled articles ready for publishing") return # Publish each scheduled article published_count = 0 for article in scheduled_articles: try: crud.publish_scheduled_article(db, article.id) published_count += 1 logger.info(f"Published scheduled article: {article.title} (ID: {article.id})") except Exception as e: logger.error(f"Failed to publish scheduled article {article.id}: {str(e)}") logger.info(f"Published {published_count} scheduled articles") except Exception as e: logger.error(f"Error in scheduled article check: {str(e)}") finally: db.close() def start_scheduler(self): """Start the background scheduler""" if not self.scheduler.running: self.scheduler.start() logger.info("Article scheduler started") def stop_scheduler(self): """Stop the background scheduler""" if self.scheduler.running: self.scheduler.shutdown() logger.info("Article scheduler stopped") def update_schedule(self, frequency_minutes: int): """Update the scheduler frequency""" try: # Remove existing job if it exists if self.scheduler.get_job(self.job_id): self.scheduler.remove_job(self.job_id) # Add new job with updated frequency self.scheduler.add_job( func=self.check_and_publish_scheduled_articles, trigger=IntervalTrigger(minutes=frequency_minutes), id=self.job_id, name="Check and publish scheduled articles", replace_existing=True ) logger.info(f"Scheduler frequency updated to {frequency_minutes} minutes") except Exception as e: logger.error(f"Failed to update scheduler frequency: {str(e)}") def initialize_scheduler(self): """Initialize scheduler with settings from database""" db: Session = SessionLocal() try: settings = crud.get_scheduler_settings(db) if not settings: # Create default settings if none exist default_settings = crud.create_scheduler_settings( db, schemas.SchedulerSettingsCreate(is_enabled=False, check_frequency_minutes=5) ) settings = default_settings # Set up the scheduler job if settings.is_enabled: self.update_schedule(settings.check_frequency_minutes) logger.info(f"Scheduler initialized with {settings.check_frequency_minutes} minute frequency") else: logger.info("Scheduler initialized but disabled") except Exception as e: logger.error(f"Failed to initialize scheduler: {str(e)}") finally: db.close() # Global scheduler instance article_scheduler = ArticleSchedulerService()

from pydantic import BaseModel, Field from typing import List, Optional from datetime import datetime, date # Category Schemas class CategoryBase(BaseModel): name: str slug: str description: Optional[str] = None class CategoryCreate(CategoryBase): pass class Category(CategoryBase): id: int created_at: datetime class Config: from_attributes = True # Article Schemas class ArticleBase(BaseModel): title: str short_title: Optional[str] = None content: str summary: str author: str language: str = "en" states: Optional[str] = None # JSON string category: str content_type: Optional[str] = "post" # New field for content type image: Optional[str] = None image_gallery: Optional[str] = None # New field for image gallery (JSON string) gallery_id: Optional[int] = None # New field for gallery reference youtube_url: Optional[str] = None tags: Optional[str] = None artists: Optional[str] = None # JSON string for artist names movie_rating: Optional[str] = None # New field for movie rating is_featured: bool = False is_published: bool = True is_scheduled: bool = False scheduled_publish_at: Optional[datetime] = None seo_title: Optional[str] = None seo_description: Optional[str] = None seo_keywords: Optional[str] = None class ArticleCreate(ArticleBase): pass class ArticleUpdate(BaseModel): title: Optional[str] = None short_title: Optional[str] = None content: Optional[str] = None summary: Optional[str] = None author: Optional[str] = None language: Optional[str] = None states: Optional[str] = None category: Optional[str] = None content_type: Optional[str] = None # New field for content type image: Optional[str] = None image_gallery: Optional[str] = None # New field for image gallery (JSON string) gallery_id: Optional[int] = None # New field for gallery reference youtube_url: Optional[str] = None tags: Optional[str] = None artists: Optional[str] = None # JSON string for artist names movie_rating: Optional[str] = None # New field for movie rating is_featured: Optional[bool] = None is_published: Optional[bool] = None is_scheduled: Optional[bool] = None scheduled_publish_at: Optional[datetime] = None seo_title: Optional[str] = None seo_description: Optional[str] = None seo_keywords: Optional[str] = None class ArticleResponse(ArticleBase): id: int slug: str view_count: int original_article_id: Optional[int] = None created_at: datetime updated_at: datetime published_at: Optional[datetime] = None gallery: Optional[dict] = None # Add gallery field for formatted response class Config: from_attributes = True # Movie Review Schemas class MovieReviewBase(BaseModel): title: str movie_name: str rating: float = Field(..., ge=0, le=5) review_content: str poster_image: Optional[str] = None director: Optional[str] = None cast: Optional[str] = None genre: Optional[str] = None reviewer: str = "Admin" class MovieReviewCreate(MovieReviewBase): pass class MovieReview(MovieReviewBase): id: int view_count: int published_at: datetime created_at: datetime class Config: from_attributes = True # Featured Image Schemas class FeaturedImageBase(BaseModel): title: str image_url: str caption: Optional[str] = None photographer: Optional[str] = None location: Optional[str] = None display_order: int = 0 is_active: bool = True class FeaturedImageCreate(FeaturedImageBase): pass class FeaturedImage(FeaturedImageBase): id: int created_at: datetime class Config: from_attributes = True # Theater Release Schemas class TheaterReleaseBase(BaseModel): movie_name: str release_date: date movie_banner: Optional[str] = None # Text field, not file path movie_image: Optional[str] = None language: str = "Hindi" class TheaterReleaseCreate(TheaterReleaseBase): created_by: str class TheaterReleaseUpdate(BaseModel): movie_name: Optional[str] = None release_date: Optional[date] = None movie_banner: Optional[str] = None # Text field, not file path movie_image: Optional[str] = None language: Optional[str] = None class TheaterReleaseResponse(TheaterReleaseBase): id: int created_by: str created_at: datetime updated_at: datetime class Config: from_attributes = True # OTT Release Schemas class OTTReleaseBase(BaseModel): movie_name: str ott_platform: str release_date: date movie_image: Optional[str] = None language: str = "Hindi" class OTTReleaseCreate(OTTReleaseBase): created_by: str class OTTReleaseUpdate(BaseModel): movie_name: Optional[str] = None ott_platform: Optional[str] = None release_date: Optional[date] = None movie_image: Optional[str] = None language: Optional[str] = None class OTTReleaseResponse(OTTReleaseBase): id: int created_by: str created_at: datetime updated_at: datetime class Config: from_attributes = True # Gallery Schema for nested gallery information class GalleryInfo(BaseModel): gallery_id: int gallery_title: str images: List[dict] first_image: Optional[dict] = None # Response Schemas class ArticleListResponse(BaseModel): id: int title: str short_title: Optional[str] = None summary: str image_url: Optional[str] = None youtube_url: Optional[str] = None # Add youtube_url field author: str language: str category: str content_type: Optional[str] = "post" # Add content_type field artists: Optional[str] = None # Add artists field states: Optional[str] = None # Add states field gallery: Optional[GalleryInfo] = None # Add gallery field is_published: bool is_scheduled: bool = False scheduled_publish_at: Optional[datetime] = None published_at: Optional[datetime] = None view_count: int class Config: from_attributes = True class MovieReviewListResponse(BaseModel): id: int title: str rating: float image_url: Optional[str] = None created_at: datetime class Config: from_attributes = True class TranslationRequest(BaseModel): article_id: int target_language: str # Language and State models for CMS class LanguageOption(BaseModel): code: str name: str native_name: str class StateOption(BaseModel): code: str name: str class CMSResponse(BaseModel): languages: List[LanguageOption] states: List[StateOption] categories: List[dict] # Scheduler Settings Schemas class SchedulerSettingsBase(BaseModel): is_enabled: bool = False check_frequency_minutes: int = 5 class SchedulerSettingsCreate(SchedulerSettingsBase): pass class SchedulerSettingsUpdate(BaseModel): is_enabled: Optional[bool] = None check_frequency_minutes: Optional[int] = None class SchedulerSettingsResponse(SchedulerSettingsBase): id: int created_at: datetime updated_at: datetime class Config: from_attributes = True # Related Articles Configuration Schemas class RelatedArticlesConfigBase(BaseModel): page: str categories: List[str] articleCount: int = 5 class RelatedArticlesConfigCreate(RelatedArticlesConfigBase): pass class RelatedArticlesConfigUpdate(BaseModel): categories: Optional[List[str]] = None articleCount: Optional[int] = None class RelatedArticlesConfigResponse(BaseModel): page_slug: str categories: List[str] article_count: int created_at: datetime updated_at: datetime class Config: from_attributes = True

from sqlalchemy.orm import Session import models from datetime import datetime, timedelta import random def seed_database(db: Session): """Seed the database with sample data""" # Clear existing data (optional - remove in production) # This is commented out to preserve existing data # Seed Categories - Updated to match frontend structure categories_data = [ # Core sections {"name": "Latest News", "slug": "latest-news", "description": "Breaking news and current affairs"}, {"name": "Politics", "slug": "politics", "description": "Political news and government updates"}, {"name": "National Top Stories", "slug": "national-top-stories", "description": "National news and top stories"}, {"name": "Movies", "slug": "movies", "description": "Movie news, updates and entertainment"}, {"name": "AI", "slug": "ai", "description": "Artificial Intelligence and technology news"}, {"name": "Stock Market", "slug": "stock-market", "description": "Stock market and financial news"}, {"name": "Sports", "slug": "sports", "description": "Sports news and updates"}, {"name": "Trending Videos", "slug": "trending-videos", "description": "Trending video content"}, {"name": "Travel Pics", "slug": "travel-pics", "description": "Travel photography and destinations"}, {"name": "Fashion", "slug": "fashion", "description": "Fashion trends and style updates"}, # Movie Reviews Section (with unique categories) {"name": "Movie Reviews", "slug": "movie-reviews", "description": "General movie reviews and critiques"}, {"name": "Movie Reviews Bollywood", "slug": "movie-reviews-bollywood", "description": "Bollywood movie reviews and critiques"}, # Row4 - Trailers & Teasers, Box Office, Theater Releases {"name": "Trailers Teasers", "slug": "trailers-teasers", "description": "Movie trailers and teasers"}, {"name": "Trailers Teasers Bollywood", "slug": "trailers-teasers-bollywood", "description": "Bollywood trailers and teasers"}, {"name": "Box Office", "slug": "box-office", "description": "Box office collections and reports"}, {"name": "Box Office Bollywood", "slug": "box-office-bollywood", "description": "Bollywood box office collections"}, {"name": "Theater Releases", "slug": "theater-releases", "description": "Theater movie releases"}, {"name": "Theater Releases Bollywood", "slug": "theater-releases-bollywood", "description": "Bollywood theater releases"}, # OTT Reviews Section {"name": "OTT Reviews", "slug": "ott-reviews", "description": "OTT platform content reviews"}, {"name": "OTT Reviews Bollywood", "slug": "ott-reviews-bollywood", "description": "Bollywood OTT platform content reviews"}, # Row5 - New Video Songs, TV Shows, OTT Releases {"name": "New Video Songs", "slug": "new-video-songs", "description": "New video songs and music videos"}, {"name": "New Video Songs Bollywood", "slug": "new-video-songs-bollywood", "description": "New Bollywood video songs and music videos"}, {"name": "TV Shows", "slug": "tv-shows", "description": "Television shows and TV content"}, {"name": "TV Shows Bollywood", "slug": "tv-shows-bollywood", "description": "Bollywood television content"}, {"name": "OTT Releases", "slug": "ott-releases", "description": "OTT platform releases"}, {"name": "OTT Releases Bollywood", "slug": "ott-releases-bollywood", "description": "Bollywood OTT platform releases"}, # Events & Interviews Section {"name": "Events Interviews", "slug": "events-interviews", "description": "Celebrity events and interviews"}, {"name": "Events Interviews Bollywood", "slug": "events-interviews-bollywood", "description": "Bollywood celebrity events and interviews"}, # Sports sections (Row3) {"name": "Sports Schedules", "slug": "sports-schedules", "description": "Sports schedules and fixtures"}, # NRI and World News sections {"name": "NRI News", "slug": "nri-news", "description": "News and updates relevant to Non-Resident Indians"}, {"name": "World News", "slug": "world-news", "description": "International news and global affairs"} ] for cat_data in categories_data: # Check if category already exists existing_category = db.query(models.Category).filter(models.Category.slug == cat_data["slug"]).first() if not existing_category: category = models.Category(**cat_data) db.add(category) db.commit() # Seed Articles with proper date distribution for filtering base_date = datetime(2026, 6, 30, 23, 59, 59) # June 30, 2026 as reference articles_data = [ # Latest News / Top Stories { "title": "Breaking: Major Policy Changes Announced Today", "slug": "major-policy-changes-today", "content": "Comprehensive policy reforms have been announced today, affecting multiple sectors...", "summary": "Government announces sweeping policy reforms across healthcare, education, and infrastructure sectors.", "author": "Political Correspondent", "published_at": base_date, "category": "latest-news", "image": "https://images.unsplash.com/photo-1495020689067-958852a7765e?w=300&h=200", "is_featured": True, "tags": "politics,policy,government" }, # Movies Section - Bollywood-Movies Tab { "title": "Bollywood Box Office Collections This Week", "slug": "bollywood-box-office-week", "content": "This week's Bollywood releases have performed exceptionally well...", "summary": "Weekly roundup of Bollywood movie box office collections and performance analysis.", "author": "Entertainment Reporter", "published_at": base_date, "category": "bollywood-movies", "image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=200", "tags": "bollywood,movies,box-office" }, { "title": "Latest Movie Releases and Reviews", "slug": "latest-movie-releases-reviews", "content": "Today's entertainment news covers major developments in the film industry...", "summary": "Major film studios announce new release schedules and production updates for upcoming blockbusters.", "author": "Film Critic", "published_at": base_date, "category": "movies", "image": "https://images.unsplash.com/photo-1518329147777-4c8fbfac0c8b?w=300&h=200", "tags": "movies,entertainment,industry" }, # Politics - State Politics Tab { "title": "State Assembly Passes New Infrastructure Bill", "slug": "state-assembly-infrastructure-bill", "content": "State legislature approves major infrastructure development project...", "summary": "State government approves multi-billion dollar infrastructure development initiative.", "author": "State Political Reporter", "published_at": base_date, "category": "state-politics", "image": "https://images.unsplash.com/photo-1577962917302-cd874c4e31d2?w=300&h=200", "tags": "state-politics,infrastructure,government" }, # Politics - National Politics Tab { "title": "National Budget Session Concludes Successfully", "slug": "national-budget-session-concludes", "content": "The national budget session concluded yesterday with significant outcomes...", "summary": "Key legislative measures passed in national budget session include budget allocations and regulatory changes.", "author": "National Political Reporter", "published_at": base_date - timedelta(days=1), "category": "national-politics", "image": "https://images.unsplash.com/photo-1586339949216-35c890863684?w=300&h=200", "tags": "national-politics,budget,government" }, # Sports - Cricket Tab { "title": "Cricket World Cup Qualifiers Begin This Month", "slug": "cricket-world-cup-qualifiers", "content": "The cricket world cup qualification matches are set to begin...", "summary": "Major cricket teams prepare for world cup qualifier tournaments starting this month.", "author": "Sports Correspondent", "published_at": base_date, "category": "cricket", "image": "https://images.unsplash.com/photo-1540747913346-19e63482ceaa?w=300&h=200", "tags": "cricket,sports,world-cup" }, # Health/Food Tab { "title": "New Nutritional Guidelines Released by Health Ministry", "slug": "new-nutritional-guidelines-health", "content": "Health ministry releases comprehensive nutritional guidelines...", "summary": "Updated dietary recommendations focus on balanced nutrition and healthy eating habits.", "author": "Health Reporter", "published_at": base_date, "category": "health", "image": "https://images.unsplash.com/photo-1490645935967-10de6ba17061?w=300&h=200", "tags": "health,nutrition,wellness" }, { "title": "Traditional Food Recipes Gain Modern Popularity", "slug": "traditional-food-recipes-modern", "content": "Traditional cooking methods and recipes are experiencing a revival...", "summary": "Modern food enthusiasts rediscover traditional recipes with contemporary cooking techniques.", "author": "Food Writer", "published_at": base_date, "category": "food", "image": "https://images.unsplash.com/photo-1556909114-f6e7ad7d3136?w=300&h=200", "tags": "food,cooking,traditional" }, # AI Section { "title": "Latest AI Tools Revolutionize Content Creation", "slug": "ai-tools-content-creation", "content": "New artificial intelligence tools are transforming how content is created...", "summary": "Revolutionary AI tools enable faster and more efficient content creation across industries.", "author": "Tech Reporter", "published_at": base_date, "category": "ai", "image": "https://images.unsplash.com/photo-1677442136019-21780ecad995?w=300&h=200", "tags": "ai,technology,innovation" }, # Stock Market/Fashion Tab { "title": "Fashion Industry Shows Strong Market Performance", "slug": "fashion-industry-market-performance", "content": "Fashion stocks demonstrate robust performance in current market conditions...", "summary": "Fashion industry stocks outperform market expectations with strong quarterly results.", "author": "Fashion Business Reporter", "published_at": base_date, "category": "fashion", "image": "https://images.unsplash.com/photo-1445205170230-053b83016050?w=300&h=200", "tags": "fashion,business,stocks" }, # Travel Tab { "title": "Exotic Travel Destinations Gain Tourist Interest", "slug": "exotic-travel-destinations-interest", "content": "Lesser-known travel destinations are becoming increasingly popular...", "summary": "Travelers seek unique experiences in off-the-beaten-path destinations around the world.", "author": "Travel Correspondent", "published_at": base_date, "category": "travel", "image": "https://images.unsplash.com/photo-1506905925346-21bda4d32df4?w=300&h=200", "tags": "travel,tourism,destinations" }, # Box Office { "title": "Weekend Box Office Collections Show Strong Growth", "slug": "weekend-box-office-collections", "content": "This weekend's box office numbers indicate strong movie industry performance...", "summary": "Movie theaters report impressive box office collections with diverse film offerings.", "author": "Box Office Analyst", "published_at": base_date, "category": "box-office", "image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=200", "tags": "box-office,movies,entertainment" }, # Trailers { "title": "Highly Anticipated Movie Trailers Released This Week", "slug": "anticipated-movie-trailers-week", "content": "This week brings exciting new movie trailers for upcoming blockbuster releases...", "summary": "Major film studios release trailers for highly anticipated movies scheduled for next quarter.", "author": "Entertainment Reporter", "published_at": base_date, "category": "trailers", "image": "https://images.unsplash.com/photo-1518329147777-4c8fbfac0c8b?w=300&h=200", "tags": "trailers,movies,entertainment" }, # Hot Topics { "title": "Social Issues Spark Nationwide Discussions", "slug": "social-issues-nationwide-discussions", "content": "Current social issues have generated widespread public discourse and debate...", "summary": "Important social topics dominate public conversation and policy discussions.", "author": "Social Affairs Reporter", "published_at": base_date, "category": "hot-topics", "image": "https://images.unsplash.com/photo-1573166364524-d9dbfd8d4c90?w=300&h=200", "tags": "social-issues,topics,discussion" }, # Gossip { "title": "Celebrity News and Entertainment Updates", "slug": "celebrity-news-entertainment-updates", "content": "Latest celebrity news brings exciting updates from the entertainment world...", "summary": "Entertainment industry buzzes with celebrity announcements and exclusive updates.", "author": "Celebrity Reporter", "published_at": base_date, "category": "gossip", "image": "https://images.unsplash.com/photo-1514525253161-7a46d19cd819?w=300&h=200", "tags": "celebrity,gossip,entertainment" }, # OTT Reviews { "title": "Latest OTT Platform Releases Reviewed", "slug": "ott-platform-releases-reviewed", "content": "This week's OTT platform releases offer diverse content across genres...", "summary": "Comprehensive reviews of new shows and movies launched on popular OTT platforms.", "author": "OTT Content Reviewer", "published_at": base_date, "category": "ott-reviews", "image": "https://images.unsplash.com/photo-1522869635100-9f4c5e86aa37?w=300&h=200", "tags": "ott,streaming,reviews" }, { "title": "Netflix Original Movies This Month", "slug": "netflix-original-movies-month", "content": "Netflix's original movie lineup this month features several standout productions...", "summary": "Review of Netflix's exclusive movie releases featuring diverse storytelling.", "author": "Streaming Content Analyst", "published_at": base_date - timedelta(days=1), "category": "ott-reviews", "image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=200", "tags": "netflix,ott,movies" }, # Movie Reviews { "title": "Latest Hollywood Blockbuster Review", "slug": "latest-hollywood-blockbuster-review", "content": "The latest Hollywood blockbuster delivers spectacular action sequences...", "summary": "Comprehensive review of the latest Hollywood blockbuster featuring stunning visuals and compelling storyline.", "author": "Movie Critic", "published_at": base_date, "category": "movie-reviews", "image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=200", "tags": "hollywood,movie-review,blockbuster" }, { "title": "Independent Film Festival Winner Review", "slug": "independent-film-festival-winner-review", "content": "This independent film festival winner showcases exceptional storytelling...", "summary": "Review of the award-winning independent film that captivated festival audiences worldwide.", "author": "Independent Film Critic", "published_at": base_date - timedelta(days=1), "category": "movie-reviews", "image": "https://images.unsplash.com/photo-1518329147777-4c8fbfac0c8b?w=300&h=200", "tags": "independent,film-festival,award-winner" }, # Movie Reviews Bollywood { "title": "Pathaan Movie Review: SRK's Grand Comeback", "slug": "pathaan-movie-review-srk-comeback", "content": "Shah Rukh Khan makes a triumphant return to the big screen with Pathaan...", "summary": "Detailed review of Pathaan showcasing SRK's powerful comeback with high-octane action sequences.", "author": "Bollywood Movie Critic", "published_at": base_date, "category": "movie-reviews-bollywood", "image": "https://images.unsplash.com/photo-1518329147777-4c8fbfac0c8b?w=300&h=200", "tags": "bollywood,pathaan,srk,movie-review" }, { "title": "Jawan Review: Action-Packed Entertainment", "slug": "jawan-review-action-packed-entertainment", "content": "Jawan delivers on its promise of mass entertainment with stellar performances...", "summary": "Comprehensive review of Jawan highlighting its entertainment value and stellar cast performances.", "author": "Bollywood Reviewer", "published_at": base_date - timedelta(days=1), "category": "movie-reviews-bollywood", "image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=200", "tags": "bollywood,jawan,action,entertainment" }, # Trailers Teasers { "title": "Upcoming Superhero Movie Trailer Breaks Records", "slug": "superhero-movie-trailer-breaks-records", "content": "The latest superhero movie trailer has shattered YouTube view records...", "summary": "New superhero trailer achieves record-breaking views within first 24 hours of release.", "author": "Entertainment Reporter", "published_at": base_date, "category": "trailers-teasers", "image": "https://images.unsplash.com/photo-1578662996442-48f60103fc96?w=300&h=200", "tags": "superhero,trailer,records,hollywood" }, { "title": "Horror Film Teaser Creates Buzz Among Fans", "slug": "horror-film-teaser-creates-buzz", "content": "The new horror film teaser has created massive excitement among horror fans...", "summary": "Latest horror film teaser generates significant buzz with spine-chilling visuals and atmosphere.", "author": "Horror Film Specialist", "published_at": base_date - timedelta(days=1), "category": "trailers-teasers", "image": "https://images.unsplash.com/photo-1440404653325-ab127d49abc1?w=300&h=200", "tags": "horror,teaser,scary,thriller" }, # Box Office { "title": "Weekend Box Office: Action Film Dominates", "slug": "weekend-box-office-action-film-dominates", "content": "This weekend's box office numbers show clear dominance by the new action film...", "summary": "Weekend box office report reveals action film's commanding performance across theaters.", "author": "Box Office Analyst", "published_at": base_date, "category": "box-office", "image": "https://images.unsplash.com/photo-1522869635100-9f4c5e86aa37?w=300&h=200", "tags": "box-office,weekend,action-film,collections" }, { "title": "International Box Office Trends This Month", "slug": "international-box-office-trends-month", "content": "International markets show interesting trends in box office performance this month...", "summary": "Analysis of international box office trends revealing shifting audience preferences globally.", "author": "International Film Analyst", "published_at": base_date - timedelta(days=2), "category": "box-office", "image": "https://images.unsplash.com/photo-1574375927938-d5a98e8ffe85?w=300&h=200", "tags": "international,box-office,trends,global" }, # Box Office Bollywood { "title": "Bollywood Box Office: Record-Breaking Collections", "slug": "bollywood-box-office-record-breaking", "content": "Bollywood films achieve record-breaking collections this quarter...", "summary": "Bollywood box office report showing exceptional performance and record-breaking collections.", "author": "Bollywood Trade Analyst", "published_at": base_date, "category": "box-office-bollywood", "image": "https://images.unsplash.com/photo-1518329147777-4c8fbfac0c8b?w=300&h=200", "tags": "bollywood,box-office,records,collections" }, { "title": "South vs North: Box Office Comparison", "slug": "south-vs-north-box-office-comparison", "content": "Comparative analysis of South Indian and Bollywood box office performance...", "summary": "Detailed comparison between South Indian and Bollywood film collections and market trends.", "author": "Regional Cinema Analyst", "published_at": base_date - timedelta(days=1), "category": "box-office-bollywood", "image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=200", "tags": "bollywood,south-indian,comparison,regional" }, # Events Interviews Bollywood { "title": "Exclusive Interview with Bollywood Superstar", "slug": "exclusive-interview-bollywood-superstar", "content": "In an exclusive interview, the Bollywood superstar shares insights about upcoming projects...", "summary": "Exclusive conversation with leading Bollywood actor discussing career milestones and future plans.", "author": "Celebrity Interviewer", "published_at": base_date, "category": "events-interviews-bollywood", "image": "https://images.unsplash.com/photo-1518329147777-4c8fbfac0c8b?w=300&h=200", "tags": "bollywood,interview,exclusive,celebrity" }, { "title": "Red Carpet Event: Bollywood Stars Shine", "slug": "red-carpet-event-bollywood-stars-shine", "content": "The red carpet event witnessed Bollywood's biggest stars in their glamorous avatars...", "summary": "Coverage of the star-studded red carpet event featuring Bollywood's finest in stunning outfits.", "author": "Event Reporter", "published_at": base_date - timedelta(days=1), "category": "events-interviews-bollywood", "image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=200", "tags": "bollywood,red-carpet,glamour,event" }, # Additional Bollywood content for different sections { "title": "Bollywood Trending Video Content Goes Viral", "slug": "bollywood-trending-video-viral", "content": "Latest Bollywood video content trends are gaining massive popularity on social platforms...", "summary": "Bollywood video content dominates trending charts across social media platforms.", "author": "Social Media Reporter", "published_at": base_date - timedelta(days=1), "category": "bollywood-trending-videos", "image": "https://images.unsplash.com/photo-1611162617474-5b21e879e113?w=300&h=200", "tags": "bollywood,trending,social-media" }, { "title": "Bollywood Box Office Records Broken This Weekend", "slug": "bollywood-box-office-records", "content": "This weekend's Bollywood box office collections have set new industry records...", "summary": "Record-breaking box office performance by Bollywood films this weekend across theaters.", "author": "Box Office Analyst", "published_at": base_date - timedelta(days=2), "category": "bollywood-box-office", "image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=200", "tags": "bollywood,box-office,records" }, { "title": "Bollywood Celebrity Interviews at Film Festival", "slug": "bollywood-celebrity-interviews-festival", "content": "Exclusive interviews with Bollywood celebrities at the recent film festival...", "summary": "Major Bollywood stars share insights in exclusive interviews during film festival events.", "author": "Entertainment Correspondent", "published_at": base_date - timedelta(days=3), "category": "bollywood-events-interviews", "image": "https://images.unsplash.com/photo-1514525253161-7a46d19cd819?w=300&h=200", "tags": "bollywood,interviews,events" }, # Top Stories { "title": "Breaking: Major Economic Policy Changes Announced", "slug": "major-economic-policy-changes", "content": "Government announces significant changes to economic policy affecting multiple sectors...", "summary": "New economic policies set to impact businesses and consumers across the country.", "author": "Economic Reporter", "published_at": base_date, "category": "top-stories", "image": "https://images.unsplash.com/photo-1454165804606-c3d57bc86b40?w=300&h=200", "tags": "economics,policy,government" }, { "title": "Technology Breakthrough Changes Industry Standards", "slug": "technology-breakthrough-industry-standards", "content": "Revolutionary technology development sets new standards for the industry...", "summary": "Groundbreaking technological advancement promises to reshape industry practices.", "author": "Tech Reporter", "published_at": base_date - timedelta(hours=2), "category": "top-stories", "image": "https://images.unsplash.com/photo-1518432031352-d6fc5c10da5a?w=300&h=200", "tags": "technology,innovation,industry" }, { "title": "International Sports Championship Underway", "slug": "international-sports-championship-underway", "content": "Major international sports championship brings together athletes from around the world...", "summary": "Athletes compete in prestigious international championship with record viewership.", "author": "Sports Correspondent", "published_at": base_date - timedelta(hours=4), "category": "top-stories", "image": "https://images.unsplash.com/photo-1504711434969-e33886168f5c?w=300&h=200", "tags": "sports,international,championship" }, { "title": "Entertainment Industry Awards Season Begins", "slug": "entertainment-awards-season-begins", "content": "The entertainment industry's most prestigious awards season officially kicks off...", "summary": "Major entertainment awards ceremonies commence with star-studded nominations.", "author": "Entertainment Reporter", "published_at": base_date - timedelta(hours=6), "category": "top-stories", "image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=200", "tags": "entertainment,awards,celebrities" }, # National Top Stories { "title": "Parliament Passes Landmark Legislation", "slug": "parliament-landmark-legislation", "content": "National parliament approves significant legislation after extensive debate...", "summary": "Historic legislative session results in the passage of groundbreaking national laws.", "author": "Political Correspondent", "published_at": base_date, "category": "national-top-stories", "image": "https://images.unsplash.com/photo-1529107386315-e1a2ed48a620?w=300&h=200", "tags": "parliament,legislation,politics" }, { "title": "National Infrastructure Development Project Launched", "slug": "national-infrastructure-development-launched", "content": "Government launches massive infrastructure development project spanning multiple states...", "summary": "Multi-billion dollar infrastructure initiative aims to modernize national transportation networks.", "author": "Infrastructure Reporter", "published_at": base_date - timedelta(hours=1), "category": "national-top-stories", "image": "https://images.unsplash.com/photo-1541888946425-d81bb19240f5?w=300&h=200", "tags": "infrastructure,development,national" }, { "title": "Supreme Court Delivers Historic Judgment", "slug": "supreme-court-historic-judgment", "content": "The nation's highest court delivers a landmark judgment on constitutional matters...", "summary": "Supreme Court's historic ruling sets important precedent for future legal cases.", "author": "Legal Affairs Reporter", "published_at": base_date - timedelta(hours=3), "category": "national-top-stories", "image": "https://images.unsplash.com/photo-1589391886645-d51941baf7fb?w=300&h=200", "tags": "supreme-court,legal,judgment" }, { "title": "National Education Reform Initiative Announced", "slug": "national-education-reform-initiative", "content": "Comprehensive education reform initiative announced to modernize national curriculum...", "summary": "Government unveils ambitious education reform plans affecting millions of students nationwide.", "author": "Education Reporter", "published_at": base_date - timedelta(hours=5), "category": "national-top-stories", "image": "https://images.unsplash.com/photo-1503676260728-1c00da094a0b?w=300&h=200", "tags": "education,reform,national" }, # Theater Releases Bollywood { "title": "Pathaan Box Office Collection Day 1", "slug": "pathaan-box-office-collection-day-1", "content": "Shah Rukh Khan's comeback film Pathaan has taken the box office by storm...", "summary": "Pathaan sets new records on opening day with massive box office collections across India.", "author": "Box Office Reporter", "published_at": base_date, "category": "theater-releases-bollywood", "image": "https://images.unsplash.com/photo-1518329147777-4c8fbfac0c8b?w=300&h=200", "tags": "bollywood,pathaan,box-office" }, { "title": "Jawan Creates History in Theaters", "slug": "jawan-creates-history-theaters", "content": "Shah Rukh Khan's Jawan has broken multiple box office records...", "summary": "Jawan becomes the highest-grossing Bollywood film of the year with unprecedented collections.", "author": "Entertainment Correspondent", "published_at": base_date - timedelta(days=1), "category": "theater-releases-bollywood", "image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=200", "tags": "bollywood,jawan,theater-release" }, { "title": "Tiger 3 Advance Booking Opens", "slug": "tiger-3-advance-booking-opens", "content": "Advance booking for Salman Khan's Tiger 3 has opened to massive response...", "summary": "Tiger 3 advance bookings indicate strong opening weekend performance for the action thriller.", "author": "Trade Analyst", "published_at": base_date - timedelta(days=2), "category": "theater-releases-bollywood", "image": "https://images.unsplash.com/photo-1578662996442-48f60103fc96?w=300&h=200", "tags": "bollywood,tiger-3,advance-booking" }, { "title": "Dunki Theater Response Overwhelms Fans", "slug": "dunki-theater-response-overwhelms-fans", "content": "Shah Rukh Khan's Dunki receives exceptional response from theater audiences...", "summary": "Dunki's unique storytelling and emotional depth create strong word-of-mouth in theaters.", "author": "Film Critic", "published_at": base_date - timedelta(days=3), "category": "theater-releases-bollywood", "image": "https://images.unsplash.com/photo-1440404653325-ab127d49abc1?w=300&h=200", "tags": "bollywood,dunki,theater-response" }, # Trailers Teasers Bollywood { "title": "Pathaan Trailer Sets Internet on Fire", "slug": "pathaan-trailer-sets-internet-on-fire", "content": "Shah Rukh Khan's comeback trailer for Pathaan has broken multiple records...", "summary": "Pathaan trailer becomes most-watched Bollywood trailer with record-breaking views in first 24 hours.", "author": "Entertainment Reporter", "published_at": base_date, "category": "trailers-teasers-bollywood", "image": "https://images.unsplash.com/photo-1518329147777-4c8fbfac0c8b?w=300&h=200", "tags": "bollywood,pathaan,trailer" }, { "title": "Jawan Teaser Creates Mass Hysteria", "slug": "jawan-teaser-creates-mass-hysteria", "content": "The first teaser of Shah Rukh Khan's Jawan has created massive buzz...", "summary": "Jawan teaser trends worldwide as fans celebrate SRK's dynamic avatar and high-octane action sequences.", "author": "Film Correspondent", "published_at": base_date - timedelta(days=1), "category": "trailers-teasers-bollywood", "image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=200", "tags": "bollywood,jawan,teaser" }, { "title": "Tiger 3 Action Trailer Breaks Records", "slug": "tiger-3-action-trailer-breaks-records", "content": "Salman Khan's Tiger 3 trailer showcases spectacular action sequences...", "summary": "Tiger 3 trailer sets new benchmarks for Bollywood action films with stunning visuals and intense sequences.", "author": "Action Film Critic", "published_at": base_date - timedelta(days=2), "category": "trailers-teasers-bollywood", "image": "https://images.unsplash.com/photo-1578662996442-48f60103fc96?w=300&h=200", "tags": "bollywood,tiger-3,action-trailer" }, { "title": "Dunki Emotional Trailer Wins Hearts", "slug": "dunki-emotional-trailer-wins-hearts", "content": "Rajkumar Hirani's Dunki trailer touches emotional chords with audiences...", "summary": "Dunki trailer showcases SRK's emotional journey with Hirani's signature storytelling and heartfelt moments.", "author": "Film Reviewer", "published_at": base_date - timedelta(days=3), "category": "trailers-teasers-bollywood", "image": "https://images.unsplash.com/photo-1440404653325-ab127d49abc1?w=300&h=200", "tags": "bollywood,dunki,emotional-trailer" }, # New Video Songs { "title": "Latest Punjabi Music Video Goes Viral", "slug": "latest-punjabi-music-video-goes-viral", "content": "The latest Punjabi music video has taken social media by storm...", "summary": "New Punjabi music video achieves record-breaking views and becomes trending topic on social platforms.", "author": "Music Reporter", "published_at": base_date, "category": "new-video-songs", "image": "https://images.unsplash.com/photo-1493225457124-a3eb161ffa5f?w=300&h=200", "tags": "music,video-songs,punjabi" }, { "title": "Independent Artist's Music Video Breaks Internet", "slug": "independent-artist-music-video-breaks-internet", "content": "An independent artist's creative music video has gone viral across platforms...", "summary": "Independent music video showcases innovative storytelling and gains millions of views within days.", "author": "Independent Music Critic", "published_at": base_date - timedelta(days=1), "category": "new-video-songs", "image": "https://images.unsplash.com/photo-1511671782779-c97d3d27a1d4?w=300&h=200", "tags": "music,independent,viral-video" }, # New Video Songs Bollywood { "title": "Pathaan Title Track Creates Dance Craze", "slug": "pathaan-title-track-creates-dance-craze", "content": "The Pathaan title track has become a massive hit with fans creating dance reels...", "summary": "Pathaan's title track becomes viral sensation as fans recreate dance moves across social media.", "author": "Bollywood Music Correspondent", "published_at": base_date, "category": "new-video-songs-bollywood", "image": "https://images.unsplash.com/photo-1518329147777-4c8fbfac0c8b?w=300&h=200", "tags": "bollywood,pathaan,music-video" }, { "title": "Jawan's 'Zinda Banda' Breaks Music Records", "slug": "jawan-zinda-banda-breaks-music-records", "content": "The song 'Zinda Banda' from Jawan has set new records for music video views...", "summary": "Jawan's 'Zinda Banda' achieves fastest 100 million views for a Bollywood music video.", "author": "Music Industry Analyst", "published_at": base_date - timedelta(days=1), "category": "new-video-songs-bollywood", "image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=200", "tags": "bollywood,jawan,music-record" }, # TV { "title": "New Crime Thriller Series Captivates Audiences", "slug": "new-crime-thriller-series-captivates-audiences", "content": "The latest crime thriller series has become viewers' favorite with its gripping storyline...", "summary": "New crime thriller series achieves highest TRP ratings with compelling narrative and stellar performances.", "author": "TV Critic", "published_at": base_date, "category": "tv", "image": "https://images.unsplash.com/photo-1522869635100-9f4c5e86aa37?w=300&h=200", "tags": "television,crime-thriller,series" }, { "title": "Reality Show Creates Nationwide Buzz", "slug": "reality-show-creates-nationwide-buzz", "content": "The new reality show format has captured audience attention across the country...", "summary": "Innovative reality show concept becomes talking point with unique format and engaging content.", "author": "Reality TV Reporter", "published_at": base_date - timedelta(days=1), "category": "tv", "image": "https://images.unsplash.com/photo-1574375927938-d5a98e8ffe85?w=300&h=200", "tags": "television,reality-show,entertainment" }, # TV Bollywood { "title": "Bollywood Stars Grace Prime Time Show", "slug": "bollywood-stars-grace-prime-time-show", "content": "Top Bollywood celebrities appeared on the popular prime time television show...", "summary": "Major Bollywood stars create television magic with their appearances on prime time shows.", "author": "TV Entertainment Reporter", "published_at": base_date, "category": "tv-bollywood", "image": "https://images.unsplash.com/photo-1518329147777-4c8fbfac0c8b?w=300&h=200", "tags": "bollywood,television,prime-time" }, { "title": "Celebrity Talk Show Breaks TRP Records", "slug": "celebrity-talk-show-breaks-trp-records", "content": "The celebrity talk show featuring Bollywood stars has achieved record TRP ratings...", "summary": "Bollywood celebrity talk show sets new television viewership records with star-studded episodes.", "author": "Television Analyst", "published_at": base_date - timedelta(days=1), "category": "tv-bollywood", "image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=200", "tags": "bollywood,talk-show,trp-record" }, # OTT Releases Bollywood { "title": "Bollywood Film Premieres Exclusively on OTT", "slug": "bollywood-film-premieres-exclusively-ott", "content": "Major Bollywood film skips theatrical release and premieres directly on OTT platform...", "summary": "High-budget Bollywood film creates buzz with direct OTT premiere breaking traditional release patterns.", "author": "OTT Platform Reporter", "published_at": base_date, "category": "ott-releases-bollywood", "image": "https://images.unsplash.com/photo-1518329147777-4c8fbfac0c8b?w=300&h=200", "tags": "bollywood,ott-release,premiere" }, { "title": "Star-Studded Web Series Announced for OTT", "slug": "star-studded-web-series-announced-ott", "content": "A new web series featuring top Bollywood actors has been announced for OTT release...", "summary": "Major OTT platform announces web series with ensemble cast of leading Bollywood celebrities.", "author": "Streaming Content Analyst", "published_at": base_date - timedelta(days=1), "category": "ott-releases-bollywood", "image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=200", "tags": "bollywood,web-series,ott-announcement" } ] # Add some additional articles for other categories articles_data.extend([ { "title": "Weekly Sports Roundup: Cricket Highlights", "slug": "weekly-sports-cricket-highlights", "content": "This week's cricket matches delivered exceptional performances...", "summary": "Comprehensive coverage of this week's cricket matches and player performances.", "author": "Sports Reporter", "published_at": base_date - timedelta(days=1), "category": "cricket", "image": "https://images.unsplash.com/photo-1540747913346-19e63482ceaa?w=300&h=200", "tags": "cricket,sports,weekly" }, { "title": "Healthy Cooking Tips for Modern Lifestyle", "slug": "healthy-cooking-tips-modern", "content": "Expert nutritionists share practical cooking tips for busy professionals...", "summary": "Learn how to maintain healthy eating habits with simple and effective cooking techniques.", "author": "Nutrition Expert", "published_at": base_date - timedelta(days=2), "category": "food", "image": "https://images.unsplash.com/photo-1556909114-f6e7ad7d3136?w=300&h=200", "tags": "food,health,cooking" }, { "title": "AI Technology Trends Shaping the Future", "slug": "ai-technology-trends-future", "content": "Emerging AI trends are revolutionizing various industries...", "summary": "Explore the latest AI developments and their impact on future technology landscape.", "author": "AI Researcher", "published_at": base_date - timedelta(days=3), "category": "ai", "image": "https://images.unsplash.com/photo-1677442136019-21780ecad995?w=300&h=200", "tags": "ai,technology,future" }, # NRI News articles { "title": "Indian Diaspora Celebrates Festival of Lights Globally", "slug": "indian-diaspora-diwali-celebrations-global", "content": "Indian communities across the world come together to celebrate Diwali with traditional fervor...", "summary": "NRI communities in USA, UK, Canada and Australia organize grand Diwali celebrations showcasing Indian culture.", "author": "NRI Correspondent", "published_at": base_date, "category": "nri-news", "image": "https://images.unsplash.com/photo-1605379399642-870262d3d051?w=300&h=200", "tags": "nri,diwali,festivals,diaspora" }, { "title": "Indian Students Excel in International Universities", "slug": "indian-students-excel-international-universities", "content": "Indian students continue to achieve remarkable success in top universities worldwide...", "summary": "Record number of Indian students receive scholarships and recognition at prestigious international institutions.", "author": "Education Reporter", "published_at": base_date - timedelta(days=1), "category": "nri-news", "image": "https://images.unsplash.com/photo-1523240795612-9a054b0db644?w=300&h=200", "tags": "nri,education,students,international" }, { "title": "Indian IT Professionals Leading Tech Innovation Abroad", "slug": "indian-it-professionals-tech-innovation-abroad", "content": "Indian IT professionals are at the forefront of technological innovations in Silicon Valley and beyond...", "summary": "Success stories of Indian technocrats who are driving innovation in major tech companies worldwide.", "author": "Tech Correspondent", "published_at": base_date - timedelta(days=2), "category": "nri-news", "image": "https://images.unsplash.com/photo-1522071820081-009f0129c71c?w=300&h=200", "tags": "nri,technology,innovation,professionals" }, { "title": "Indian Restaurants Gain Recognition in World Food Scene", "slug": "indian-restaurants-world-food-scene-recognition", "content": "Indian restaurants and chefs are receiving international acclaim for authentic cuisine...", "summary": "Michelin stars and international awards highlight the growing recognition of Indian culinary excellence globally.", "author": "Food Critic", "published_at": base_date - timedelta(days=3), "category": "nri-news", "image": "https://images.unsplash.com/photo-1567188040759-fb8a883dc6d8?w=300&h=200", "tags": "nri,food,restaurants,culinary" }, # World News articles { "title": "Global Climate Summit Reaches Historic Agreement", "slug": "global-climate-summit-historic-agreement", "content": "World leaders unite at the climate summit to address urgent environmental challenges...", "summary": "194 nations commit to ambitious carbon reduction targets and renewable energy transition plans.", "author": "International Correspondent", "published_at": base_date, "category": "world-news", "image": "https://images.unsplash.com/photo-1569163139394-de4e4f43e4e4?w=300&h=200", "tags": "world,climate,environment,summit" }, { "title": "International Trade Relations Show Positive Trends", "slug": "international-trade-relations-positive-trends", "content": "Global trade partnerships strengthen as countries rebuild post-pandemic economies...", "summary": "Trade volumes reach pre-pandemic levels with new bilateral agreements boosting economic cooperation.", "author": "Economic Analyst", "published_at": base_date - timedelta(days=1), "category": "world-news", "image": "https://images.unsplash.com/photo-1526304640581-d334cdbbf45e?w=300&h=200", "tags": "world,trade,economy,international" }, { "title": "Space Exploration Achievements Mark New Era", "slug": "space-exploration-achievements-new-era", "content": "International space agencies collaborate on groundbreaking missions to Mars and beyond...", "summary": "Joint space missions demonstrate unprecedented international cooperation in scientific exploration.", "author": "Science Reporter", "published_at": base_date - timedelta(days=2), "category": "world-news", "image": "https://images.unsplash.com/photo-1446776653964-20c1d3a81b06?w=300&h=200", "tags": "world,space,exploration,science" }, { "title": "Global Education Initiatives Transform Learning", "slug": "global-education-initiatives-transform-learning", "content": "UNESCO and partner organizations launch innovative education programs worldwide...", "summary": "Digital learning platforms and international exchange programs revolutionize global education access.", "author": "Education Correspondent", "published_at": base_date - timedelta(days=3), "category": "world-news", "image": "https://images.unsplash.com/photo-1503676260728-1c00da094a0b?w=300&h=200", "tags": "world,education,unesco,learning" } ]) for article_data in articles_data: # Check if article already exists existing_article = db.query(models.Article).filter(models.Article.slug == article_data["slug"]).first() if not existing_article: article = models.Article(**article_data) db.add(article) db.commit() # Seed Movie Reviews movie_reviews_data = [ { "title": "Spectacular Superhero Adventure", "movie_name": "The Cosmic Guardian", "director": "Alex Rodriguez", "cast": "Emma Stone, Chris Evans, Michael Shannon", "genre": "Action/Adventure", "rating": 8.5, "review_content": "A visually stunning superhero film that delivers on both action and emotional depth...", "reviewer": "James Wilson", "published_at": base_date - timedelta(days=2), "poster_image": "https://images.unsplash.com/photo-1518329147777-4c8fbfac0c8b?w=300&h=450" }, { "title": "Intimate Drama That Captivates", "movie_name": "Whispers in the Wind", "director": "Sarah Chen", "cast": "Viola Davis, Oscar Isaac, Lupita Nyong'o", "genre": "Drama", "rating": 9.2, "review_content": "A masterpiece of storytelling that explores the depths of human relationships...", "reviewer": "Maria Lopez", "published_at": base_date - timedelta(days=5), "poster_image": "https://images.unsplash.com/photo-1533174072545-7a4b6ad7a6c3?w=300&h=450" }, { "title": "Comedy Gold with Heart", "movie_name": "Late Night Laughs", "director": "Mike Johnson", "cast": "Tina Fey, Steve Carell, Mindy Kaling", "genre": "Comedy", "rating": 7.8, "review_content": "A hilarious comedy that doesn't forget to have a heart at its center...", "reviewer": "David Kim", "published_at": base_date - timedelta(days=10), "poster_image": "https://images.unsplash.com/photo-1489599112477-990c2cb2c508?w=300&h=450" } ] for review_data in movie_reviews_data: # Check if review already exists existing_review = db.query(models.MovieReview).filter(models.MovieReview.movie_name == review_data["movie_name"]).first() if not existing_review: review = models.MovieReview(**review_data) db.add(review) db.commit() # Seed Featured Images featured_images_data = [ { "title": "City Skyline at Sunset", "image_url": "https://images.unsplash.com/photo-1449824913935-59a10b8d2000?w=800&h=600", "caption": "Beautiful city skyline captured during golden hour", "photographer": "John Smith", "location": "New York City", "display_order": 1 }, { "title": "Mountain Landscape", "image_url": "https://images.unsplash.com/photo-1506905925346-21bda4d32df4?w=800&h=600", "caption": "Breathtaking mountain vista with morning mist", "photographer": "Jane Doe", "location": "Rocky Mountains", "display_order": 2 }, { "title": "Ocean Waves", "image_url": "https://images.unsplash.com/photo-1544551763-46a013bb70d5?w=800&h=600", "caption": "Powerful ocean waves crashing against the shore", "photographer": "Mike Wilson", "location": "Pacific Coast", "display_order": 3 }, { "title": "Forest Path", "image_url": "https://images.unsplash.com/photo-1441974231531-c6227db76b6e?w=800&h=600", "caption": "Serene forest path surrounded by ancient trees", "photographer": "Sarah Johnson", "location": "Olympic National Park", "display_order": 4 }, { "title": "Desert Sunset", "image_url": "https://images.unsplash.com/photo-1509316975850-ff9c5deb0cd9?w=800&h=600", "caption": "Stunning sunset over the desert landscape", "photographer": "Carlos Rodriguez", "location": "Mojave Desert", "display_order": 5 } ] for image_data in featured_images_data: # Check if image already exists existing_image = db.query(models.FeaturedImage).filter(models.FeaturedImage.title == image_data["title"]).first() if not existing_image: image = models.FeaturedImage(**image_data) db.add(image) db.commit() print(f"Database seeded successfully!") print(f"Categories: {len(categories_data)}") print(f"Articles: {len(articles_data)}") print(f"Movie Reviews: {len(movie_reviews_data)}") print(f"Featured Images: {len(featured_images_data)}")

from fastapi import FastAPI, APIRouter, Depends, HTTPException, UploadFile, File, Form, Request from fastapi.middleware.cors import CORSMiddleware from fastapi.staticfiles import StaticFiles from sqlalchemy.orm import Session from sqlalchemy import or_, desc from typing import List, Optional import logging from pathlib import Path from datetime import datetime, date import os import uuid import aiofiles # Rate limiting completely disabled for better user experience # All rate limiting functionality removed from database import SessionLocal, engine, get_db, Base import models, schemas, crud, seed_data from models import Gallery # Import Gallery specifically from routes.auth_routes import router as auth_router from routes.topics_routes import router as topics_router from routes.gallery_routes import router as gallery_router from auth import create_default_admin from scheduler_service import article_scheduler # Create database tables Base.metadata.create_all(bind=engine) ROOT_DIR = Path(__file__).parent UPLOAD_DIR = ROOT_DIR / "uploads" UPLOAD_DIR.mkdir(exist_ok=True) # Create the main app without any rate limiting app = FastAPI(title="Blog CMS API", version="1.0.0") # Serve uploaded files statically app.mount("/uploads", StaticFiles(directory=str(UPLOAD_DIR)), name="uploads") # Create a router with the /api prefix api_router = APIRouter(prefix="/api") # Health check endpoint @api_router.get("/") async def root(request: Request): return {"message": "Blog CMS API is running", "status": "healthy"} # Seed database endpoint (for development) @api_router.post("/seed-database") async def seed_database_endpoint(db: Session = Depends(get_db)): try: seed_data.seed_database(db) return {"message": "Database seeded successfully"} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) # Category endpoints @api_router.get("/categories", response_model=List[schemas.Category]) async def get_categories(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)): categories = crud.get_categories(db, skip=skip, limit=limit) return categories @api_router.post("/categories", response_model=schemas.Category) async def create_category(category: schemas.CategoryCreate, db: Session = Depends(get_db)): db_category = crud.get_category_by_slug(db, slug=category.slug) if db_category: raise HTTPException(status_code=400, detail="Category with this slug already exists") return crud.create_category(db=db, category=category) # Article endpoints @api_router.get("/articles", response_model=List[schemas.ArticleListResponse]) async def get_articles( request: Request, skip: int = 0, limit: int = 100, category_id: Optional[int] = None, is_featured: Optional[bool] = None, db: Session = Depends(get_db) ): articles = crud.get_articles(db, skip=skip, limit=limit, is_featured=is_featured) result = [] for article in articles: result.append({ "id": article.id, "title": article.title, "short_title": article.short_title, "summary": article.summary, "image_url": article.image, "author": article.author, "language": article.language, "category": article.category, "content_type": article.content_type, # Add content_type field "artists": article.artists, # Add artists field "is_published": article.is_published, "is_scheduled": article.is_scheduled if article.is_scheduled is not None else False, "scheduled_publish_at": article.scheduled_publish_at, "published_at": article.published_at, "view_count": article.view_count if article.view_count is not None else 0 }) return result @api_router.get("/articles/category/{category_slug}", response_model=List[schemas.ArticleListResponse]) async def get_articles_by_category(category_slug: str, skip: int = 0, limit: int = 15, db: Session = Depends(get_db)): articles = crud.get_articles_by_category_slug(db, category_slug=category_slug, skip=skip, limit=limit) result = [] for article in articles: result.append({ "id": article.id, "title": article.title, "short_title": article.short_title, "summary": article.summary, "image_url": article.image, "author": article.author, "language": article.language, "category": article.category, "content_type": article.content_type, # Add content_type field "artists": article.artists, # Add artists field "is_published": article.is_published, "is_scheduled": article.is_scheduled, "scheduled_publish_at": article.scheduled_publish_at, "published_at": article.published_at, "view_count": article.view_count }) return result # New section-specific endpoints for frontend sections @api_router.get("/articles/sections/latest-news", response_model=List[schemas.ArticleListResponse]) async def get_latest_news_articles(request: Request, limit: int = 4, db: Session = Depends(get_db)): """Get articles for Latest News/Top Stories section""" articles = crud.get_articles_by_category_slug(db, category_slug="latest-news", limit=limit) return _format_article_response(articles, db) @api_router.get("/articles/sections/politics", response_model=dict) async def get_politics_articles( request: Request, limit: int = 4, states: str = None, # Comma-separated list of state codes: "ap,ts" db: Session = Depends(get_db) ): """Get articles for Politics section with State and National tabs Args: limit: Number of articles to return per section states: Comma-separated state codes (e.g., "ap,ts") to filter state politics articles """ # Parse state codes if provided state_codes = [] if states: state_codes = [s.strip().lower() for s in states.split(',') if s.strip()] # Get state politics articles with state filtering if state_codes: state_articles = crud.get_articles_by_states(db, category_slug="state-politics", state_codes=state_codes, limit=limit) else: # If no states specified, get all state politics articles state_articles = crud.get_articles_by_category_slug(db, category_slug="state-politics", limit=limit) # National politics articles don't need state filtering national_articles = crud.get_articles_by_category_slug(db, category_slug="national-politics", limit=limit) return { "state_politics": _format_article_response(state_articles, db), "national_politics": _format_article_response(national_articles, db) } @api_router.get("/articles/sections/movies", response_model=dict) async def get_movies_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for Movies section with Movie News and Movie News Bollywood tabs""" movie_news_articles = crud.get_articles_by_category_slug(db, category_slug="movie-news", limit=limit) bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="movie-news-bollywood", limit=limit) return { "movies": _format_article_response(movie_news_articles, db), "bollywood": _format_article_response(bollywood_articles, db) } @api_router.get("/articles/sections/hot-topics", response_model=dict) async def get_hot_topics_articles(limit: int = 4, states: str = None, db: Session = Depends(get_db)): """Get articles for Hot Topics section with Hot Topics (state-specific) and Hot Topics Bollywood tabs""" # For hot topics tab - apply state filtering if provided (similar to politics filtering) if states: # Convert state codes to filter hot-topics articles state_codes = [code.strip() for code in states.split(',')] hot_topics_articles = crud.get_articles_by_states(db, category_slug="hot-topics", state_codes=state_codes, limit=limit) else: hot_topics_articles = crud.get_articles_by_category_slug(db, category_slug="hot-topics", limit=limit) # Bollywood hot topics - no state filtering needed (show to all users) bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="hot-topics-bollywood", limit=limit) return { "hot_topics": _format_article_response(hot_topics_articles, db), "bollywood": _format_article_response(bollywood_articles, db) } @api_router.get("/articles/sections/ai-stock", response_model=dict) async def get_ai_stock_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for AI & Stock Market section""" ai_articles = crud.get_articles_by_category_slug(db, category_slug="ai", limit=limit) stock_articles = crud.get_articles_by_category_slug(db, category_slug="stock-market", limit=limit) return { "ai": _format_article_response(ai_articles, db), "stock_market": _format_article_response(stock_articles, db) } @api_router.get("/articles/sections/fashion-beauty", response_model=dict) async def get_fashion_beauty_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for Fashion & Beauty section (now Fashion & Travel)""" fashion_articles = crud.get_articles_by_category_slug(db, category_slug="fashion", limit=limit) travel_articles = crud.get_articles_by_category_slug(db, category_slug="travel", limit=limit) return { "fashion": _format_article_response(fashion_articles, db), "travel": _format_article_response(travel_articles, db) } @api_router.get("/articles/sections/sports", response_model=dict) async def get_sports_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for Sports section with Cricket and Other Sports tabs""" cricket_articles = crud.get_articles_by_category_slug(db, category_slug="cricket", limit=limit) other_sports_articles = crud.get_articles_by_category_slug(db, category_slug="other-sports", limit=limit) return { "cricket": _format_article_response(cricket_articles, db), "other_sports": _format_article_response(other_sports_articles, db) } @api_router.get("/articles/sections/hot-topics-gossip", response_model=dict) async def get_hot_topics_gossip_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for Hot Topics & Gossip section""" hot_topics_articles = crud.get_articles_by_category_slug(db, category_slug="hot-topics", limit=limit) gossip_articles = crud.get_articles_by_category_slug(db, category_slug="gossip", limit=limit) return { "hot_topics": _format_article_response(hot_topics_articles, db), "gossip": _format_article_response(gossip_articles, db) } @api_router.get("/articles/sections/box-office", response_model=dict) async def get_box_office_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for Box Office section with Box Office and Bollywood-Box Office tabs""" box_office_articles = crud.get_articles_by_category_slug(db, category_slug="box-office", limit=limit) bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="bollywood-box-office", limit=limit) return { "box_office": _format_article_response(box_office_articles, db), "bollywood": _format_article_response(bollywood_articles, db) } @api_router.get("/articles/sections/trending-videos", response_model=dict) async def get_trending_videos_articles(limit: int = 20, states: str = None, db: Session = Depends(get_db)): """Get articles for Trending Videos section with Trending Videos and Bollywood-Trending Videos tabs Args: limit: Number of articles to fetch (default 20) states: Comma-separated list of states for trending videos filtering (Bollywood tab ignores state filtering) """ # For trending videos tab - apply state filtering if provided if states: # Convert state names to state codes (map full names to codes) state_name_to_code = { 'Andhra Pradesh': 'ap', 'Telangana': 'ts', # Add more mappings as needed } state_list = [state.strip() for state in states.split(',') if state.strip()] state_codes = [] for state_name in state_list: if state_name in state_name_to_code: state_codes.append(state_name_to_code[state_name]) if state_codes: trending_articles = crud.get_articles_by_states(db, category_slug="trending-videos", state_codes=state_codes, limit=limit) else: trending_articles = crud.get_articles_by_category_slug(db, category_slug="trending-videos", limit=limit) else: trending_articles = crud.get_articles_by_category_slug(db, category_slug="trending-videos", limit=limit) # For Bollywood tab - no state filtering, show all Bollywood trending videos bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="bollywood-trending-videos", limit=limit) return { "trending_videos": _format_article_response(trending_articles, db), "bollywood": _format_article_response(bollywood_articles, db) } # USA and ROW video sections endpoint @api_router.get("/articles/sections/usa-row-videos", response_model=dict) async def get_usa_row_videos_sections(limit: int = 20, db: Session = Depends(get_db)): """Get articles for Viral Videos section with USA and ROW tabs""" usa_articles = crud.get_articles_by_category_slug(db, category_slug="usa", limit=limit) row_articles = crud.get_articles_by_category_slug(db, category_slug="row", limit=limit) return { "usa": _format_article_response(usa_articles, db), "row": _format_article_response(row_articles, db) } @api_router.get("/articles/sections/viral-shorts", response_model=dict) async def get_viral_shorts_articles(limit: int = 20, states: str = None, db: Session = Depends(get_db)): """Get articles for Viral Shorts section with Viral Shorts and Bollywood tabs Args: limit: Number of articles to fetch (default 20) states: Comma-separated list of states for viral shorts filtering (Bollywood tab ignores state filtering) """ # For viral shorts tab - apply state filtering if provided if states: # Convert state names to state codes (map full names to codes) state_name_to_code = { 'Andhra Pradesh': 'ap', 'Telangana': 'ts', 'Karnataka': 'ka', 'Tamil Nadu': 'tn', 'Kerala': 'kl', 'Maharashtra': 'mh', 'Gujarat': 'gj', 'Rajasthan': 'rj', 'Uttar Pradesh': 'up', 'West Bengal': 'wb', 'Bihar': 'br', 'Madhya Pradesh': 'mp', 'Odisha': 'or', 'Punjab': 'pb', 'Haryana': 'hr', 'Assam': 'as', 'Jharkhand': 'jh', 'Chhattisgarh': 'cg', 'Himachal Pradesh': 'hp', 'Uttarakhand': 'uk', 'Jammu and Kashmir': 'jk', 'Delhi': 'dl', 'Goa': 'ga', 'Manipur': 'mn', 'Meghalaya': 'ml', 'Mizoram': 'mz', 'Nagaland': 'nl', 'Sikkim': 'sk', 'Tripura': 'tr', 'Arunachal Pradesh': 'ar', 'Ladakh': 'ld' } state_list = [state.strip() for state in states.split(',') if state.strip()] state_codes = [] for state_name in state_list: if state_name in state_name_to_code: state_codes.append(state_name_to_code[state_name]) if state_codes: viral_shorts_articles = crud.get_articles_by_states(db, category_slug="viral-shorts", state_codes=state_codes, limit=limit) else: viral_shorts_articles = crud.get_articles_by_category_slug(db, category_slug="viral-shorts", limit=limit) else: viral_shorts_articles = crud.get_articles_by_category_slug(db, category_slug="viral-shorts", limit=limit) # For Bollywood tab - no state filtering, show all Viral Shorts Bollywood videos bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="viral-shorts-bollywood", limit=limit) return { "viral_shorts": _format_article_response(viral_shorts_articles, db), "bollywood": _format_article_response(bollywood_articles, db) } @api_router.get("/articles/sections/ott-movie-reviews", response_model=dict) async def get_ott_movie_reviews_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for OTT Reviews section with OTT Reviews and Bollywood tabs""" ott_reviews_articles = crud.get_articles_by_category_slug(db, category_slug="ott-reviews", limit=limit) bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="ott-reviews-bollywood", limit=limit) return { "ott_movie_reviews": _format_article_response(ott_reviews_articles, db), "web_series": _format_article_response(bollywood_articles, db) } @api_router.get("/articles/sections/events-interviews", response_model=dict) async def get_events_interviews_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for Events & Interviews section with Events & Interviews and Events Interviews Bollywood tabs""" events_articles = crud.get_articles_by_category_slug(db, category_slug="events-interviews", limit=limit) bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="events-interviews-bollywood", limit=limit) return { "events_interviews": _format_article_response(events_articles, db), "bollywood": _format_article_response(bollywood_articles, db) } @api_router.get("/articles/sections/new-video-songs", response_model=dict) async def get_new_video_songs_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for New Video Songs section with Video Songs and Bollywood tabs""" video_songs_articles = crud.get_articles_by_category_slug(db, category_slug="new-video-songs", limit=limit) bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="new-video-songs-bollywood", limit=limit) return { "video_songs": _format_article_response(video_songs_articles, db), "bollywood": _format_article_response(bollywood_articles, db) } @api_router.get("/articles/sections/movie-reviews", response_model=dict) async def get_movie_reviews_articles(limit: int = 20, db: Session = Depends(get_db)): """Get articles for Movie Reviews section with Movie Reviews and Bollywood tabs - latest 20 from each category""" movie_reviews_articles = crud.get_articles_by_category_slug(db, category_slug="movie-reviews", limit=limit) bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="movie-reviews-bollywood", limit=limit) return { "movie_reviews": _format_article_response(movie_reviews_articles, db), "bollywood": _format_article_response(bollywood_articles, db) } @api_router.get("/articles/sections/trailers-teasers", response_model=dict) async def get_trailers_teasers_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for Trailers & Teasers section with Trailers and Bollywood tabs""" trailers_articles = crud.get_articles_by_category_slug(db, category_slug="trailers-teasers", limit=limit) bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="trailers-teasers-bollywood", limit=limit) return { "trailers": _format_article_response(trailers_articles, db), "bollywood": _format_article_response(bollywood_articles, db) } @api_router.get("/articles/sections/box-office", response_model=dict) async def get_box_office_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for Box Office section with Box Office and Bollywood tabs""" box_office_articles = crud.get_articles_by_category_slug(db, category_slug="box-office", limit=limit) bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="box-office-bollywood", limit=limit) return { "box_office": _format_article_response(box_office_articles, db), "bollywood": _format_article_response(bollywood_articles, db) } @api_router.get("/articles/sections/events-interviews", response_model=dict) async def get_events_interviews_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for Events & Interviews section with Events and Bollywood tabs""" events_articles = crud.get_articles_by_category_slug(db, category_slug="events-interviews", limit=limit) bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="events-interviews-bollywood", limit=limit) return { "events": _format_article_response(events_articles, db), "bollywood": _format_article_response(bollywood_articles, db) } @api_router.get("/articles/sections/tv-shows", response_model=dict) async def get_tv_shows_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for TV Shows section with TV Shows and Bollywood tabs""" tv_articles = crud.get_articles_by_category_slug(db, category_slug="tv-shows", limit=limit) bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="tv-shows-bollywood", limit=limit) return { "tv": _format_article_response(tv_articles), "bollywood": _format_article_response(bollywood_articles) } # Frontend endpoint for OTT releases with Bollywood @api_router.get("/releases/ott-bollywood") async def get_ott_bollywood_releases(db: Session = Depends(get_db)): """Get OTT and Bollywood OTT releases for homepage display""" this_week_ott = crud.get_this_week_ott_releases(db, limit=4) upcoming_ott = crud.get_upcoming_ott_releases(db, limit=4) # Get Bollywood OTT release articles instead of regular articles bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="ott-releases-bollywood", limit=4) def format_release_response(releases, is_ott=True): result = [] for release in releases: release_data = { "id": release.id, "movie_name": release.movie_name, "language": release.language, "release_date": release.release_date, "movie_image": release.movie_image, "created_at": release.created_at } if is_ott: release_data["ott_platform"] = release.ott_platform result.append(release_data) return result def format_article_response(articles): result = [] for article in articles: result.append({ "id": article.id, "title": article.title, "movie_name": article.title, # Use title as movie name "summary": article.summary, "image_url": article.image, "movie_image": article.image, # Use article image as movie image "author": article.author, "language": article.language or "Hindi", "category": article.category, "published_at": article.published_at, "release_date": article.published_at, # Use published date as release date "ott_platform": "Netflix" # Default platform for Bollywood articles }) return result return { "ott": { "this_week": format_release_response(this_week_ott, True), "coming_soon": format_release_response(upcoming_ott, True) }, "bollywood": { "this_week": format_article_response(bollywood_articles[:2]), # First 2 as this week "coming_soon": format_article_response(bollywood_articles[2:]) # Rest as coming soon } } @api_router.get("/articles/sections/trailers", response_model=List[schemas.ArticleListResponse]) async def get_trailers_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for Trailers & Teasers section""" articles = crud.get_articles_by_category_slug(db, category_slug="trailers", limit=limit) return _format_article_response(articles) @api_router.get("/articles/sections/top-stories", response_model=dict) async def get_top_stories_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for Top Stories section with regular and national tabs""" top_stories_articles = crud.get_articles_by_category_slug(db, category_slug="top-stories", limit=limit) national_articles = crud.get_articles_by_category_slug(db, category_slug="national-top-stories", limit=limit) return { "top_stories": _format_article_response(top_stories_articles), "national": _format_article_response(national_articles) } @api_router.get("/articles/sections/nri-news", response_model=List[schemas.ArticleListResponse]) async def get_nri_news_articles(limit: int = 4, states: str = None, db: Session = Depends(get_db)): """Get articles for NRI News section with state filtering""" # Parse state codes from query parameter state_codes = [] if states: state_codes = [s.strip().lower() for s in states.split(',') if s.strip()] # Get NRI News articles with state filtering if state_codes: articles = crud.get_articles_by_states(db, category_slug="nri-news", state_codes=state_codes, limit=limit) else: # If no states specified, get all NRI news articles articles = crud.get_articles_by_category_slug(db, category_slug="nri-news", limit=limit) return _format_article_response(articles) @api_router.get("/articles/sections/world-news", response_model=List[schemas.ArticleListResponse]) async def get_world_news_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for World News section""" articles = crud.get_articles_by_category_slug(db, category_slug="world-news", limit=limit) return _format_article_response(articles) @api_router.get("/articles/sections/photoshoots", response_model=List[schemas.ArticleListResponse]) async def get_photoshoots_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for Photoshoots section""" articles = crud.get_articles_by_category_slug(db, category_slug="photoshoots", limit=limit) return _format_article_response(articles, db) @api_router.get("/articles/sections/travel-pics", response_model=List[schemas.ArticleListResponse]) async def get_travel_pics_articles(limit: int = 4, db: Session = Depends(get_db)): """Get articles for Travel Pics section""" articles = crud.get_articles_by_category_slug(db, category_slug="travel-pics", limit=limit) return _format_article_response(articles, db) # Helper function to format article response def _format_article_response(articles, db: Session = None): """Helper function to format article list response""" result = [] for article in articles: # Get gallery information if article has gallery_id gallery_info = None if hasattr(article, 'gallery_id') and article.gallery_id and db: # Load gallery data gallery = db.query(models.Gallery).filter(models.Gallery.id == article.gallery_id).first() if gallery and gallery.images: try: import json gallery_images = json.loads(gallery.images) gallery_info = { "gallery_id": gallery.id, "gallery_title": gallery.title, "images": gallery_images, "first_image": gallery_images[0] if gallery_images else None } except: gallery_info = None # Determine the image URL to use image_url = article.image if gallery_info and gallery_info["first_image"]: # Use first gallery image as thumbnail image_url = gallery_info["first_image"].get("url", article.image) result.append({ "id": article.id, "title": article.title, "short_title": article.short_title, "content": article.content if hasattr(article, 'content') else "", "summary": article.summary, "slug": article.slug if hasattr(article, 'slug') else "", "image_url": image_url, # Use gallery first image if available "youtube_url": article.youtube_url, # Add youtube_url for video content "author": article.author, "language": article.language, "category": article.category, "content_type": article.content_type, # Add content_type field "artists": article.artists, # Add artists field "states": article.states, # Add states field for state-specific filtering "gallery": gallery_info, # Add gallery information "is_published": article.is_published, "is_scheduled": article.is_scheduled, "scheduled_publish_at": article.scheduled_publish_at, "published_at": article.published_at, "view_count": article.view_count, "created_at": article.created_at if hasattr(article, 'created_at') else None, "updated_at": article.updated_at if hasattr(article, 'updated_at') else None }) return result # CMS API Endpoints @api_router.get("/cms/config", response_model=schemas.CMSResponse) async def get_cms_config(db: Session = Depends(get_db)): """Get CMS configuration including languages, states, and categories""" categories = crud.get_all_categories(db) languages = [ {"code": "en", "name": "English", "native_name": "English"}, {"code": "te", "name": "Telugu", "native_name": "తెలుగు"}, {"code": "hi", "name": "Hindi", "native_name": "हिन्दी"}, {"code": "ta", "name": "Tamil", "native_name": "தமிழ்"}, {"code": "kn", "name": "Kannada", "native_name": "ಕನ್ನಡ"}, {"code": "mr", "name": "Marathi", "native_name": "मराठी"}, {"code": "gu", "name": "Gujarati", "native_name": "ગુજરાતી"}, {"code": "bn", "name": "Bengali", "native_name": "বাংলা"}, {"code": "ml", "name": "Malayalam", "native_name": "മലയാളം"}, {"code": "pa", "name": "Punjabi", "native_name": "ਪੰਜਾਬੀ"}, {"code": "as", "name": "Assamese", "native_name": "অসমীয়া"}, {"code": "or", "name": "Odia", "native_name": "ଓଡ଼ିଆ"}, {"code": "kok", "name": "Konkani", "native_name": "कोंकणी"}, {"code": "mni", "name": "Manipuri", "native_name": "ꯃꯤꯇꯩꯂꯣꯟ"}, {"code": "ne", "name": "Nepali", "native_name": "नेपाली"}, {"code": "ur", "name": "Urdu", "native_name": "اردو"} ] states = [ {"code": "all", "name": "All States"}, {"code": "ap", "name": "Andhra Pradesh"}, {"code": "ar", "name": "Arunachal Pradesh"}, {"code": "as", "name": "Assam"}, {"code": "br", "name": "Bihar"}, {"code": "cg", "name": "Chhattisgarh"}, {"code": "dl", "name": "Delhi"}, {"code": "ga", "name": "Goa"}, {"code": "gj", "name": "Gujarat"}, {"code": "hr", "name": "Haryana"}, {"code": "hp", "name": "Himachal Pradesh"}, {"code": "jk", "name": "Jammu and Kashmir"}, {"code": "jh", "name": "Jharkhand"}, {"code": "ka", "name": "Karnataka"}, {"code": "kl", "name": "Kerala"}, {"code": "ld", "name": "Ladakh"}, {"code": "mp", "name": "Madhya Pradesh"}, {"code": "mh", "name": "Maharashtra"}, {"code": "mn", "name": "Manipur"}, {"code": "ml", "name": "Meghalaya"}, {"code": "mz", "name": "Mizoram"}, {"code": "nl", "name": "Nagaland"}, {"code": "or", "name": "Odisha"}, {"code": "pb", "name": "Punjab"}, {"code": "rj", "name": "Rajasthan"}, {"code": "sk", "name": "Sikkim"}, {"code": "tn", "name": "Tamil Nadu"}, {"code": "ts", "name": "Telangana"}, {"code": "tr", "name": "Tripura"}, {"code": "up", "name": "Uttar Pradesh"}, {"code": "uk", "name": "Uttarakhand"}, {"code": "wb", "name": "West Bengal"} ] return { "languages": languages, "states": states, "categories": [{"id": cat.id, "name": cat.name, "slug": cat.slug, "description": cat.description} for cat in categories] } @api_router.get("/cms/articles", response_model=List[schemas.ArticleListResponse]) async def get_cms_articles( language: str = "en", skip: int = 0, limit: int = 20, category: str = None, state: str = None, db: Session = Depends(get_db) ): """Get articles for CMS dashboard with filtering""" articles = crud.get_articles_for_cms(db, language=language, skip=skip, limit=limit, category=category, state=state) result = [] for article in articles: result.append({ "id": article.id, "title": article.title, "short_title": article.short_title, "summary": article.summary, "image_url": article.image, "author": article.author, "language": article.language, "category": article.category, "content_type": article.content_type, # Add content_type field "artists": article.artists, # Add artists field "is_published": article.is_published, "is_scheduled": article.is_scheduled if article.is_scheduled is not None else False, "scheduled_publish_at": article.scheduled_publish_at, "published_at": article.published_at, "view_count": article.view_count if article.view_count is not None else 0 }) return result @api_router.post("/cms/articles", response_model=schemas.ArticleResponse) async def create_cms_article(article: schemas.ArticleCreate, db: Session = Depends(get_db)): """Create new article via CMS""" # Generate slug from title import re slug = re.sub(r'[^a-zA-Z0-9\s]', '', article.title.lower()) slug = re.sub(r'\s+', '-', slug.strip()) # Create SEO fields if not provided seo_title = article.seo_title or article.title seo_description = article.seo_description or article.summary[:155] # Create article in database db_article = crud.create_article_cms(db, article, slug, seo_title, seo_description) return db_article @api_router.get("/cms/articles/{article_id}", response_model=schemas.ArticleResponse) async def get_cms_article(article_id: int, db: Session = Depends(get_db)): """Get single article for editing""" article = crud.get_article_by_id(db, article_id) if not article: raise HTTPException(status_code=404, detail="Article not found") return article @api_router.put("/cms/articles/{article_id}", response_model=schemas.ArticleResponse) async def update_cms_article( article_id: int, article_update: schemas.ArticleUpdate, db: Session = Depends(get_db) ): """Update article via CMS""" article = crud.get_article_by_id(db, article_id) if not article: raise HTTPException(status_code=404, detail="Article not found") updated_article = crud.update_article_cms(db, article_id, article_update) return updated_article @api_router.delete("/cms/articles/{article_id}") async def delete_cms_article(article_id: int, db: Session = Depends(get_db)): """Delete article via CMS""" article = crud.get_article_by_id(db, article_id) if not article: raise HTTPException(status_code=404, detail="Article not found") crud.delete_article(db, article_id) return {"message": "Article deleted successfully"} @api_router.get("/articles/{article_id}/related-videos") async def get_article_related_videos(article_id: int, db: Session = Depends(get_db)): """Get related videos for an article""" article = crud.get_article_by_id(db, article_id) if not article: raise HTTPException(status_code=404, detail="Article not found") # For now, return empty list since we need to implement related videos storage # This will be populated when we add the database schema for related videos return {"related_videos": []} @api_router.put("/articles/{article_id}/related-videos") async def update_article_related_videos( article_id: int, request: dict, db: Session = Depends(get_db) ): """Update related videos for an article""" article = crud.get_article_by_id(db, article_id) if not article: raise HTTPException(status_code=404, detail="Article not found") related_video_ids = request.get("related_videos", []) # Validate that all related video IDs exist and are video articles for video_id in related_video_ids: video_article = crud.get_article_by_id(db, video_id) if not video_article: raise HTTPException(status_code=400, detail=f"Related video with ID {video_id} not found") if not video_article.youtube_url: raise HTTPException(status_code=400, detail=f"Article with ID {video_id} is not a video article") # For now, we'll store the related videos in a simple way # In a production system, you'd want a proper many-to-many relationship table # For this implementation, we'll use a simple approach # Store related videos as a JSON string in a custom field (to be added to schema) # This is a simplified implementation - in production you'd want proper relationships try: import json related_videos_json = json.dumps(related_video_ids) # Update article with related videos (this assumes we add a related_videos column) # For now, we'll simulate success since we need to update the database schema first return {"message": "Related videos updated successfully", "related_videos": related_video_ids} except Exception as e: raise HTTPException(status_code=500, detail="Failed to update related videos") @api_router.post("/cms/articles/{article_id}/translate", response_model=schemas.ArticleResponse) async def translate_article( article_id: int, translation_request: schemas.TranslationRequest, db: Session = Depends(get_db) ): """Create translated version of article""" original_article = crud.get_article_by_id(db, article_id) if not original_article: raise HTTPException(status_code=404, detail="Original article not found") # Here you would integrate with translation service (Google Translate, etc.) # For now, we'll create a copy with the target language translated_article = crud.create_translated_article(db, original_article, translation_request.target_language) return translated_article @api_router.get("/articles/most-read", response_model=List[schemas.ArticleListResponse]) async def get_most_read_articles(limit: int = 15, db: Session = Depends(get_db)): articles = crud.get_most_read_articles(db, limit=limit) result = [] for article in articles: result.append({ "id": article.id, "title": article.title, "short_title": article.short_title, "summary": article.summary, "image_url": article.image, "author": article.author, "language": article.language, "category": article.category, "content_type": article.content_type, # Add content_type field "artists": article.artists, # Add artists field "is_published": article.is_published, "is_scheduled": article.is_scheduled, "scheduled_publish_at": article.scheduled_publish_at, "published_at": article.published_at, "view_count": article.view_count }) return result @api_router.get("/articles/featured", response_model=schemas.ArticleResponse) async def get_featured_article(db: Session = Depends(get_db)): articles = crud.get_articles(db, limit=1, is_featured=True) if not articles: raise HTTPException(status_code=404, detail="No featured article found") return articles[0] @api_router.get("/articles/{article_id}", response_model=schemas.ArticleResponse) async def get_article(request: Request, article_id: int, db: Session = Depends(get_db)): article = crud.get_article(db, article_id=article_id) if article is None: raise HTTPException(status_code=404, detail="Article not found") print(f"Debug: Article {article_id} has gallery_id: {getattr(article, 'gallery_id', 'MISSING')}") # Use the same formatting function to include gallery information formatted_articles = _format_article_response([article], db) print(f"Debug: Formatted response gallery: {formatted_articles[0].get('gallery') if formatted_articles else 'NO FORMATTED'}") return formatted_articles[0] if formatted_articles else article @api_router.post("/articles", response_model=schemas.ArticleResponse) async def create_article(article: schemas.ArticleCreate, db: Session = Depends(get_db)): return crud.create_article(db=db, article=article) # Movie Review endpoints @api_router.get("/movie-reviews", response_model=List[schemas.MovieReviewListResponse]) async def get_movie_reviews(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)): reviews = crud.get_movie_reviews(db, skip=skip, limit=limit) result = [] for review in reviews: result.append({ "id": review.id, "title": review.title, "rating": review.rating, "image_url": review.poster_image, "created_at": review.created_at }) return result @api_router.get("/movie-reviews/{review_id}", response_model=schemas.MovieReview) async def get_movie_review(review_id: int, db: Session = Depends(get_db)): review = crud.get_movie_review(db, review_id=review_id) if review is None: raise HTTPException(status_code=404, detail="Movie review not found") return review @api_router.post("/movie-reviews", response_model=schemas.MovieReview) async def create_movie_review(review: schemas.MovieReviewCreate, db: Session = Depends(get_db)): return crud.create_movie_review(db=db, review=review) # Featured Images endpoints @api_router.get("/featured-images", response_model=List[schemas.FeaturedImage]) async def get_featured_images(limit: int = 5, db: Session = Depends(get_db)): return crud.get_featured_images(db, limit=limit) @api_router.post("/featured-images", response_model=schemas.FeaturedImage) async def create_featured_image(image: schemas.FeaturedImageCreate, db: Session = Depends(get_db)): return crud.create_featured_image(db=db, image=image) # Scheduler Settings endpoints @api_router.get("/admin/scheduler-settings", response_model=schemas.SchedulerSettingsResponse) async def get_scheduler_settings(db: Session = Depends(get_db)): """Get current scheduler settings (Admin only)""" settings = crud.get_scheduler_settings(db) if not settings: # Create default settings if none exist settings = crud.create_scheduler_settings( db, schemas.SchedulerSettingsCreate(is_enabled=False, check_frequency_minutes=5) ) return settings @api_router.put("/admin/scheduler-settings", response_model=schemas.SchedulerSettingsResponse) async def update_scheduler_settings( settings_update: schemas.SchedulerSettingsUpdate, db: Session = Depends(get_db) ): """Update scheduler settings (Admin only)""" updated_settings = crud.update_scheduler_settings(db, settings_update) # Update the background scheduler if settings_update.is_enabled is not None: if settings_update.is_enabled: article_scheduler.start_scheduler() frequency = settings_update.check_frequency_minutes or updated_settings.check_frequency_minutes article_scheduler.update_schedule(frequency) else: article_scheduler.stop_scheduler() if settings_update.check_frequency_minutes is not None and updated_settings.is_enabled: article_scheduler.update_schedule(settings_update.check_frequency_minutes) return updated_settings @api_router.post("/admin/scheduler/run-now") async def run_scheduler_now(): """Manually trigger scheduled article publishing (Admin only)""" try: article_scheduler.check_and_publish_scheduled_articles() return {"message": "Scheduler run completed successfully"} except Exception as e: raise HTTPException(status_code=500, detail=f"Scheduler run failed: {str(e)}") @api_router.get("/cms/scheduled-articles") async def get_scheduled_articles(db: Session = Depends(get_db)): """Get all scheduled articles""" scheduled_articles = db.query(models.Article).filter( models.Article.is_scheduled == True, models.Article.is_published == False ).order_by(models.Article.scheduled_publish_at).all() result = [] for article in scheduled_articles: result.append({ "id": article.id, "title": article.title, "short_title": article.short_title, "author": article.author, "language": article.language, "category": article.category, "scheduled_publish_at": article.scheduled_publish_at, "created_at": article.created_at }) return result # Analytics tracking endpoint @api_router.post("/analytics/track") async def track_analytics(tracking_data: dict): """ Track user interactions for analytics and SEO purposes """ try: # Log the tracking data (in production, you'd save to database) import logging logging.info(f"Analytics Tracking: {tracking_data}") # Here you can save to database, send to analytics service, etc. # For now, we'll just return success return { "status": "success", "message": "Analytics data tracked successfully", "timestamp": tracking_data.get("timestamp") } except Exception as e: raise HTTPException(status_code=500, detail=f"Analytics tracking failed: {str(e)}") # Related Articles Configuration endpoints @api_router.get("/cms/related-articles-config") async def get_related_articles_config(page: str = None, db: Session = Depends(get_db)): """Get related articles configuration for a specific page or all pages""" try: config = crud.get_related_articles_config(db, page_slug=page) return config except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @api_router.post("/cms/related-articles-config") async def create_related_articles_config( config_data: schemas.RelatedArticlesConfigCreate, db: Session = Depends(get_db) ): """Create or update related articles configuration""" try: config = crud.create_or_update_related_articles_config(db, config_data) return {"message": "Configuration saved successfully", "config": config} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @api_router.delete("/cms/related-articles-config/{page_slug}") async def delete_related_articles_config(page_slug: str, db: Session = Depends(get_db)): """Delete related articles configuration for a page""" try: deleted_config = crud.delete_related_articles_config(db, page_slug) if not deleted_config: raise HTTPException(status_code=404, detail="Configuration not found") return {"message": "Configuration deleted successfully"} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @api_router.get("/related-articles/{page_slug}") async def get_related_articles_for_page( page_slug: str, limit: int = None, db: Session = Depends(get_db) ): """Get related articles for a specific page based on its configuration""" try: articles = crud.get_related_articles_for_page(db, page_slug, limit) # Format the response result = [] for article in articles: result.append({ "id": article.id, "title": article.title, "short_title": article.short_title, "summary": article.summary, "image": article.image, "author": article.author, "language": article.language, "category": article.category, "published_at": article.published_at, "view_count": article.view_count }) return result except Exception as e: raise HTTPException(status_code=500, detail=str(e)) # File upload helper functions async def save_uploaded_file(upload_file: UploadFile, subfolder: str) -> str: """Save uploaded file and return the file path""" if not upload_file.filename: raise HTTPException(status_code=400, detail="No file selected") # Generate unique filename file_extension = os.path.splitext(upload_file.filename)[1] unique_filename = f"{uuid.uuid4()}{file_extension}" # Create subfolder path subfolder_path = UPLOAD_DIR / subfolder subfolder_path.mkdir(exist_ok=True) # Save file file_path = subfolder_path / unique_filename async with aiofiles.open(file_path, 'wb') as f: content = await upload_file.read() await f.write(content) # Return relative path for storage in database return f"uploads/{subfolder}/{unique_filename}" # Theater Release endpoints @api_router.get("/cms/theater-releases", response_model=List[schemas.TheaterReleaseResponse]) async def get_theater_releases(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)): """Get all theater releases for CMS""" releases = crud.get_theater_releases(db, skip=skip, limit=limit) return releases @api_router.get("/cms/theater-releases/{release_id}", response_model=schemas.TheaterReleaseResponse) async def get_theater_release(release_id: int, db: Session = Depends(get_db)): """Get single theater release""" release = crud.get_theater_release(db, release_id) if not release: raise HTTPException(status_code=404, detail="Theater release not found") return release @api_router.post("/cms/theater-releases", response_model=schemas.TheaterReleaseResponse) async def create_theater_release( movie_name: str = Form(...), movie_banner: str = Form(...), # Changed to string form field language: str = Form("Hindi"), # Added language field release_date: date = Form(...), created_by: str = Form(...), movie_image: UploadFile = File(None), db: Session = Depends(get_db) ): """Create new theater release with file uploads""" try: # Save uploaded image image_path = None if movie_image: image_path = await save_uploaded_file(movie_image, "theater_releases") # Create release data release_data = schemas.TheaterReleaseCreate( movie_name=movie_name, movie_banner=movie_banner, # Store as text language=language, release_date=release_date, created_by=created_by, movie_image=image_path ) return crud.create_theater_release(db, release_data) except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @api_router.put("/cms/theater-releases/{release_id}", response_model=schemas.TheaterReleaseResponse) async def update_theater_release( release_id: int, movie_name: Optional[str] = Form(None), movie_banner: Optional[str] = Form(None), # Text field language: Optional[str] = Form(None), # Added language field release_date: Optional[date] = Form(None), movie_image: UploadFile = File(None), db: Session = Depends(get_db) ): """Update theater release""" try: # Check if release exists existing_release = crud.get_theater_release(db, release_id) if not existing_release: raise HTTPException(status_code=404, detail="Theater release not found") # Prepare update data update_data = {} if movie_name: update_data["movie_name"] = movie_name if movie_banner: update_data["movie_banner"] = movie_banner if language: update_data["language"] = language if release_date: update_data["release_date"] = release_date # Handle file upload if movie_image: update_data["movie_image"] = await save_uploaded_file(movie_image, "theater_releases") release_update = schemas.TheaterReleaseUpdate(**update_data) return crud.update_theater_release(db, release_id, release_update) except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @api_router.delete("/cms/theater-releases/{release_id}") async def delete_theater_release(release_id: int, db: Session = Depends(get_db)): """Delete theater release""" release = crud.get_theater_release(db, release_id) if not release: raise HTTPException(status_code=404, detail="Theater release not found") crud.delete_theater_release(db, release_id) return {"message": "Theater release deleted successfully"} # OTT Release endpoints @api_router.get("/cms/ott-releases", response_model=List[schemas.OTTReleaseResponse]) async def get_ott_releases(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)): """Get all OTT releases for CMS""" releases = crud.get_ott_releases(db, skip=skip, limit=limit) return releases @api_router.get("/cms/ott-releases/{release_id}", response_model=schemas.OTTReleaseResponse) async def get_ott_release(release_id: int, db: Session = Depends(get_db)): """Get single OTT release""" release = crud.get_ott_release(db, release_id) if not release: raise HTTPException(status_code=404, detail="OTT release not found") return release @api_router.get("/cms/ott-platforms") async def get_ott_platforms(): """Get list of available OTT platforms""" return {"platforms": crud.get_ott_platforms()} @api_router.post("/cms/ott-releases", response_model=schemas.OTTReleaseResponse) async def create_ott_release( movie_name: str = Form(...), ott_platform: str = Form(...), language: str = Form("Hindi"), # Added language field release_date: date = Form(...), created_by: str = Form(...), movie_image: UploadFile = File(None), db: Session = Depends(get_db) ): """Create new OTT release with file upload""" try: # Save uploaded file image_path = None if movie_image: image_path = await save_uploaded_file(movie_image, "ott_releases") # Create release data release_data = schemas.OTTReleaseCreate( movie_name=movie_name, ott_platform=ott_platform, language=language, release_date=release_date, created_by=created_by, movie_image=image_path ) return crud.create_ott_release(db, release_data) except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @api_router.put("/cms/ott-releases/{release_id}", response_model=schemas.OTTReleaseResponse) async def update_ott_release( release_id: int, movie_name: Optional[str] = Form(None), ott_platform: Optional[str] = Form(None), language: Optional[str] = Form(None), # Added language field release_date: Optional[date] = Form(None), movie_image: UploadFile = File(None), db: Session = Depends(get_db) ): """Update OTT release""" try: # Check if release exists existing_release = crud.get_ott_release(db, release_id) if not existing_release: raise HTTPException(status_code=404, detail="OTT release not found") # Prepare update data update_data = {} if movie_name: update_data["movie_name"] = movie_name if ott_platform: update_data["ott_platform"] = ott_platform if language: update_data["language"] = language if release_date: update_data["release_date"] = release_date # Handle file upload if movie_image: update_data["movie_image"] = await save_uploaded_file(movie_image, "ott_releases") release_update = schemas.OTTReleaseUpdate(**update_data) return crud.update_ott_release(db, release_id, release_update) except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @api_router.delete("/cms/ott-releases/{release_id}") async def delete_ott_release(release_id: int, db: Session = Depends(get_db)): """Delete OTT release""" release = crud.get_ott_release(db, release_id) if not release: raise HTTPException(status_code=404, detail="OTT release not found") crud.delete_ott_release(db, release_id) return {"message": "OTT release deleted successfully"} # Frontend endpoints for homepage with Bollywood theater releases @api_router.get("/releases/theater-bollywood") async def get_homepage_theater_bollywood_releases(db: Session = Depends(get_db)): """Get theater and Bollywood theater releases for homepage display""" this_week_theater = crud.get_this_week_theater_releases(db, limit=4) upcoming_theater = crud.get_upcoming_theater_releases(db, limit=4) # Get Bollywood theater release articles instead of OTT releases bollywood_articles = crud.get_articles_by_category_slug(db, category_slug="theater-releases-bollywood", limit=4) def format_release_response(releases, is_theater=True): result = [] for release in releases: release_data = { "id": release.id, "movie_name": release.movie_name, "language": release.language, "release_date": release.release_date, "movie_image": release.movie_image, "created_at": release.created_at } if is_theater: release_data["movie_banner"] = release.movie_banner else: release_data["ott_platform"] = release.ott_platform result.append(release_data) return result def format_article_response(articles): result = [] for article in articles: result.append({ "id": article.id, "title": article.title, "movie_name": article.title, # Use title as movie name "summary": article.summary, "image_url": article.image, "movie_image": article.image, # Use article image as movie image "author": article.author, "language": article.language or "Hindi", "category": article.category, "published_at": article.published_at, "release_date": article.published_at # Use published date as release date }) return result return { "theater": { "this_week": format_release_response(this_week_theater, True), "coming_soon": format_release_response(upcoming_theater, True) }, "ott": { "this_week": format_article_response(bollywood_articles[:2]), # First 2 as this week "coming_soon": format_article_response(bollywood_articles[2:]) # Rest as coming soon } } # Original endpoint kept for backward compatibility @api_router.get("/releases/theater-ott") async def get_homepage_releases(db: Session = Depends(get_db)): """Get theater and OTT releases for homepage display""" this_week_theater = crud.get_this_week_theater_releases(db, limit=4) upcoming_theater = crud.get_upcoming_theater_releases(db, limit=4) this_week_ott = crud.get_this_week_ott_releases(db, limit=4) upcoming_ott = crud.get_upcoming_ott_releases(db, limit=4) def format_release_response(releases, is_theater=True): result = [] for release in releases: release_data = { "id": release.id, "movie_name": release.movie_name, "language": release.language, "release_date": release.release_date, "movie_image": release.movie_image, "created_at": release.created_at } if is_theater: release_data["movie_banner"] = release.movie_banner else: release_data["ott_platform"] = release.ott_platform result.append(release_data) return result return { "theater": { "this_week": format_release_response(this_week_theater, True), "coming_soon": format_release_response(upcoming_theater, True) }, "ott": { "this_week": format_release_response(this_week_ott, False), "coming_soon": format_release_response(upcoming_ott, False) } } # Frontend endpoints for theater-ott-releases page @api_router.get("/releases/theater-ott/page") async def get_theater_ott_page_releases( release_type: str = "theater", # "theater" or "ott" filter_type: str = "upcoming", # "upcoming", "this_month", "all" skip: int = 0, limit: int = 20, db: Session = Depends(get_db) ): """Get releases for theater-ott-releases page with filters""" try: if release_type == "theater": if filter_type == "upcoming": releases = crud.get_upcoming_theater_releases(db, limit=limit) else: releases = crud.get_theater_releases(db, skip=skip, limit=limit) def format_theater_response(releases): result = [] for release in releases: result.append({ "id": release.id, "movie_name": release.movie_name, "language": release.language, "release_date": release.release_date, "movie_image": release.movie_image, "movie_banner": release.movie_banner, "created_at": release.created_at }) return result return format_theater_response(releases) else: # ott if filter_type == "upcoming": releases = crud.get_upcoming_ott_releases(db, limit=limit) else: releases = crud.get_ott_releases(db, skip=skip, limit=limit) def format_ott_response(releases): result = [] for release in releases: result.append({ "id": release.id, "movie_name": release.movie_name, "language": release.language, "release_date": release.release_date, "movie_image": release.movie_image, "ott_platform": release.ott_platform, "created_at": release.created_at }) return result return format_ott_response(releases) except Exception as e: raise HTTPException(status_code=500, detail=str(e)) # Movie content endpoints @api_router.get("/articles/movie/{movie_name}") async def get_articles_by_movie_name(movie_name: str, db: Session = Depends(get_db)): """Get all articles tagged with a specific movie name""" try: # Search for articles by movie name in title or tags articles = db.query(models.Article).filter( or_( models.Article.title.ilike(f"%{movie_name}%"), models.Article.tags.ilike(f"%{movie_name}%") ) ).filter(models.Article.is_published == True).order_by(desc(models.Article.published_at)).all() return articles except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @api_router.get("/articles/search") async def search_articles(q: str, db: Session = Depends(get_db)): """Search articles by query in title, content, or tags""" try: articles = db.query(models.Article).filter( or_( models.Article.title.ilike(f"%{q}%"), models.Article.content.ilike(f"%{q}%"), models.Article.tags.ilike(f"%{q}%") ) ).filter(models.Article.is_published == True).order_by(desc(models.Article.published_at)).limit(50).all() return articles except Exception as e: raise HTTPException(status_code=500, detail=str(e)) # Include routers app.include_router(api_router) app.include_router(auth_router) # Add authentication routes app.include_router(topics_router, prefix="/api") # Add topics routes app.include_router(gallery_router, prefix="/api") # Add gallery routes app.add_middleware( CORSMiddleware, allow_credentials=True, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"], ) # Configure logging logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' ) logger = logging.getLogger(__name__) @app.on_event("startup") async def startup_event(): logger.info("Blog CMS API starting up...") # Create default admin user await create_default_admin() # Initialize the article scheduler article_scheduler.initialize_scheduler() article_scheduler.start_scheduler() @app.on_event("shutdown") async def shutdown_event(): logger.info("Blog CMS API shutting down...") # Stop the article scheduler article_scheduler.stop_scheduler()

#!/usr/bin/env python3 """ Update Movies Categories Script =============================== This script updates the category names: - "Movies" -> "Movie News" - "Bollywood-Movies" -> "Movie News Bollywood" And updates their slugs: - "movies" -> "movie-news" - "bollywood-movies" -> "movie-news-bollywood" """ import sys from pathlib import Path # Add the backend directory to the Python path backend_dir = Path(__file__).parent sys.path.append(str(backend_dir)) from sqlalchemy.orm import Session from database import SessionLocal, engine from models.database_models import Category def update_movie_categories(): """Update movie categories to new names and slugs""" db = SessionLocal() try: print("🔄 Updating movie categories...") # Update "Movies" category movies_category = db.query(Category).filter(Category.slug == "movies").first() if movies_category: old_name = movies_category.name old_slug = movies_category.slug movies_category.name = "Movie News" movies_category.slug = "movie-news" movies_category.description = "Movie news, updates and entertainment" print(f"✅ Updated: '{old_name}' (slug: '{old_slug}') -> '{movies_category.name}' (slug: '{movies_category.slug}')") else: print("❌ Movies category not found") # Update "Bollywood-Movies" category bollywood_category = db.query(Category).filter(Category.slug == "bollywood-movies").first() if bollywood_category: old_name = bollywood_category.name old_slug = bollywood_category.slug bollywood_category.name = "Movie News Bollywood" bollywood_category.slug = "movie-news-bollywood" bollywood_category.description = "Bollywood movie news and entertainment" print(f"✅ Updated: '{old_name}' (slug: '{old_slug}') -> '{bollywood_category.name}' (slug: '{bollywood_category.slug}')") else: print("❌ Bollywood-Movies category not found") # Update articles that use these categories print("\n🔄 Updating articles with new category names...") # Update articles in "movies" category movies_articles = db.query(Category).filter(Category.slug == "movies").first() if movies_articles: from models.database_models import Article articles_count = db.query(Article).filter(Article.category == "movies").count() if articles_count > 0: db.query(Article).filter(Article.category == "movies").update({"category": "movie-news"}) print(f"✅ Updated {articles_count} articles from 'movies' to 'movie-news' category") # Update articles in "bollywood-movies" category bollywood_articles = db.query(Category).filter(Category.slug == "bollywood-movies").first() if bollywood_articles: articles_count = db.query(Article).filter(Article.category == "bollywood-movies").count() if articles_count > 0: db.query(Article).filter(Article.category == "bollywood-movies").update({"category": "movie-news-bollywood"}) print(f"✅ Updated {articles_count} articles from 'bollywood-movies' to 'movie-news-bollywood' category") # Commit all changes db.commit() print("\n🎉 Successfully updated movie categories!") # Verify the changes print("\n📋 Verification:") updated_movies = db.query(Category).filter(Category.slug == "movie-news").first() updated_bollywood = db.query(Category).filter(Category.slug == "movie-news-bollywood").first() if updated_movies: print(f"✅ Movie News: {updated_movies.name} (slug: {updated_movies.slug})") if updated_bollywood: print(f"✅ Movie News Bollywood: {updated_bollywood.name} (slug: {updated_bollywood.slug})") except Exception as e: print(f"❌ Error updating categories: {e}") db.rollback() raise finally: db.close() if __name__ == "__main__": update_movie_categories()

#!/usr/bin/env python3 import requests import json import unittest import os import sys from datetime import datetime # Get the backend URL from the frontend .env file with open('/app/frontend/.env', 'r') as f: for line in f: if line.startswith('REACT_APP_BACKEND_URL='): BACKEND_URL = line.strip().split('=')[1].strip('"\'') break API_URL = f"{BACKEND_URL}/api" print(f"Testing API at: {API_URL}") class ComprehensiveBackendTest(unittest.TestCase): """Comprehensive test suite for the Blog CMS API after UI height changes""" def setUp(self): """Set up test fixtures before each test method""" # Seed the database to ensure we have data to test with response = requests.post(f"{API_URL}/seed-database") self.assertEqual(response.status_code, 200, "Failed to seed database") print("Database seeded successfully") def test_health_check(self): """Test the health check endpoint""" print("\n--- Testing Health Check Endpoint ---") response = requests.get(f"{API_URL}/") self.assertEqual(response.status_code, 200, "Health check failed") data = response.json() self.assertEqual(data["message"], "Blog CMS API is running") self.assertEqual(data["status"], "healthy") print("✅ Health check endpoint working") def test_database_connectivity(self): """Test database connectivity by verifying data retrieval""" print("\n--- Testing Database Connectivity ---") # Test categories retrieval response = requests.get(f"{API_URL}/categories") self.assertEqual(response.status_code, 200, "Failed to get categories") categories = response.json() self.assertGreater(len(categories), 0, "No categories returned from database") print(f"✅ Database connectivity working - retrieved {len(categories)} categories") # Test articles retrieval response = requests.get(f"{API_URL}/articles") self.assertEqual(response.status_code, 200, "Failed to get articles") articles = response.json() self.assertGreater(len(articles), 0, "No articles returned from database") print(f"✅ Database connectivity working - retrieved {len(articles)} articles") # Test movie reviews retrieval response = requests.get(f"{API_URL}/movie-reviews") self.assertEqual(response.status_code, 200, "Failed to get movie reviews") reviews = response.json() self.assertGreater(len(reviews), 0, "No movie reviews returned from database") print(f"✅ Database connectivity working - retrieved {len(reviews)} movie reviews") # Test featured images retrieval response = requests.get(f"{API_URL}/featured-images") self.assertEqual(response.status_code, 200, "Failed to get featured images") images = response.json() self.assertGreater(len(images), 0, "No featured images returned from database") print(f"✅ Database connectivity working - retrieved {len(images)} featured images") def test_articles_api_with_pagination(self): """Test articles API with various pagination parameters""" print("\n--- Testing Articles API with Pagination ---") # Test default pagination response = requests.get(f"{API_URL}/articles") self.assertEqual(response.status_code, 200, "Failed to get articles") articles = response.json() total_articles = len(articles) print(f"Total articles: {total_articles}") # Test with small limit limit = 5 response = requests.get(f"{API_URL}/articles?limit={limit}") self.assertEqual(response.status_code, 200, "Failed to get articles with limit") limited_articles = response.json() self.assertLessEqual(len(limited_articles), limit, f"Limit parameter not working, got {len(limited_articles)} articles instead of {limit}") print(f"✅ Articles pagination with limit={limit} working") # Test with skip skip = 10 response = requests.get(f"{API_URL}/articles?skip={skip}") self.assertEqual(response.status_code, 200, "Failed to get articles with skip") skipped_articles = response.json() if total_articles > skip: self.assertLessEqual(len(skipped_articles), total_articles - skip, "Skip parameter not working correctly") print(f"✅ Articles pagination with skip={skip} working") # Test with both skip and limit skip = 15 limit = 10 response = requests.get(f"{API_URL}/articles?skip={skip}&limit={limit}") self.assertEqual(response.status_code, 200, "Failed to get articles with skip and limit") paginated_articles = response.json() self.assertLessEqual(len(paginated_articles), limit, "Pagination with skip and limit not working correctly") print(f"✅ Articles pagination with skip={skip} and limit={limit} working") def test_categories_api(self): """Test categories API functionality""" print("\n--- Testing Categories API ---") # Get all categories response = requests.get(f"{API_URL}/categories") self.assertEqual(response.status_code, 200, "Failed to get categories") categories = response.json() self.assertGreater(len(categories), 0, "No categories returned") print(f"✅ GET categories endpoint working, returned {len(categories)} categories") # Verify category structure category = categories[0] required_fields = ["id", "name", "slug", "description", "created_at"] for field in required_fields: self.assertIn(field, category, f"Category missing required field: {field}") print("✅ Category data structure is correct") # Test creating a new category with unique slug unique_timestamp = datetime.now().strftime("%Y%m%d%H%M%S") new_category = { "name": f"Test Category {unique_timestamp}", "slug": f"test-category-{unique_timestamp}", "description": "This is a test category created during comprehensive testing" } response = requests.post(f"{API_URL}/categories", json=new_category) self.assertEqual(response.status_code, 200, "Failed to create category") created_category = response.json() self.assertEqual(created_category["name"], new_category["name"]) self.assertEqual(created_category["slug"], new_category["slug"]) print("✅ POST categories endpoint working with unique slug") # Test creating a category with duplicate slug (should fail) response = requests.post(f"{API_URL}/categories", json=new_category) self.assertEqual(response.status_code, 400, "Duplicate slug validation failed") print("✅ Category duplicate slug validation working") def test_movie_reviews_api(self): """Test movie reviews API functionality""" print("\n--- Testing Movie Reviews API ---") # Get all movie reviews response = requests.get(f"{API_URL}/movie-reviews") self.assertEqual(response.status_code, 200, "Failed to get movie reviews") reviews = response.json() self.assertGreater(len(reviews), 0, "No movie reviews returned") print(f"✅ GET movie reviews endpoint working, returned {len(reviews)} reviews") # Get a specific movie review review_id = reviews[0]["id"] response = requests.get(f"{API_URL}/movie-reviews/{review_id}") self.assertEqual(response.status_code, 200, f"Failed to get movie review with ID {review_id}") review = response.json() self.assertEqual(review["id"], review_id) required_fields = ["title", "rating", "content", "image_url", "director", "cast", "genre"] for field in required_fields: self.assertIn(field, review, f"Movie review missing required field: {field}") print(f"✅ GET movie review by ID endpoint working for review ID {review_id}") # Create a new movie review unique_timestamp = datetime.now().strftime("%Y%m%d%H%M%S") new_review = { "title": f"Test Movie Review {unique_timestamp}", "rating": 4.7, "content": "This is a test movie review created during comprehensive testing", "image_url": "https://example.com/test-movie.jpg", "director": "Test Director", "cast": "Actor 1, Actor 2, Actor 3", "genre": "Action/Drama", "reviewer": "Test Reviewer", "is_published": True } response = requests.post(f"{API_URL}/movie-reviews", json=new_review) self.assertEqual(response.status_code, 200, "Failed to create movie review") created_review = response.json() self.assertEqual(created_review["title"], new_review["title"]) self.assertEqual(created_review["rating"], new_review["rating"]) print("✅ POST movie reviews endpoint working") def test_featured_images_api(self): """Test featured images API functionality""" print("\n--- Testing Featured Images API ---") # Get all featured images response = requests.get(f"{API_URL}/featured-images") self.assertEqual(response.status_code, 200, "Failed to get featured images") images = response.json() self.assertGreater(len(images), 0, "No featured images returned") print(f"✅ GET featured images endpoint working, returned {len(images)} images") # Test limit parameter limit = 2 response = requests.get(f"{API_URL}/featured-images?limit={limit}") self.assertEqual(response.status_code, 200, f"Failed to get featured images with limit={limit}") limited_images = response.json() self.assertLessEqual(len(limited_images), limit, f"Limit parameter not working, got {len(limited_images)} images instead of {limit}") print(f"✅ Featured images limit parameter working with limit={limit}") # Create a new featured image unique_timestamp = datetime.now().strftime("%Y%m%d%H%M%S") new_image = { "title": f"Test Featured Image {unique_timestamp}", "image_url": "https://example.com/test-featured.jpg", "link_url": "/articles/1", "description": "This is a test featured image created during comprehensive testing", "order_index": 10, "is_active": True } response = requests.post(f"{API_URL}/featured-images", json=new_image) self.assertEqual(response.status_code, 200, "Failed to create featured image") created_image = response.json() self.assertEqual(created_image["title"], new_image["title"]) self.assertEqual(created_image["image_url"], new_image["image_url"]) print("✅ POST featured images endpoint working") def test_article_view_count_increment(self): """Test article view count increment functionality""" print("\n--- Testing Article View Count Increment ---") # Get an article ID response = requests.get(f"{API_URL}/articles") self.assertEqual(response.status_code, 200, "Failed to get articles") articles = response.json() article_id = articles[0]["id"] initial_view_count = articles[0]["view_count"] print(f"Testing article ID {article_id} with initial view count {initial_view_count}") # View the article to increment view count response = requests.get(f"{API_URL}/articles/{article_id}") self.assertEqual(response.status_code, 200, f"Failed to get article with ID {article_id}") # Get the article again to check if view count incremented response = requests.get(f"{API_URL}/articles") self.assertEqual(response.status_code, 200, "Failed to get articles") updated_articles = response.json() # Find the same article in the updated list updated_article = None for article in updated_articles: if article["id"] == article_id: updated_article = article break self.assertIsNotNone(updated_article, f"Could not find article with ID {article_id} in updated list") self.assertEqual(updated_article["view_count"], initial_view_count + 1, f"View count did not increment correctly. Expected {initial_view_count + 1}, got {updated_article['view_count']}") print(f"✅ Article view count increment working. Initial: {initial_view_count}, Updated: {updated_article['view_count']}") def test_cors_configuration(self): """Test CORS configuration""" print("\n--- Testing CORS Configuration ---") # Test with OPTIONS request response = requests.options(f"{API_URL}/", headers={ "Origin": "http://example.com", "Access-Control-Request-Method": "GET" }) self.assertEqual(response.status_code, 200, "OPTIONS request failed") # Check CORS headers self.assertIn("Access-Control-Allow-Origin", response.headers, "Missing Access-Control-Allow-Origin header") self.assertIn("Access-Control-Allow-Methods", response.headers, "Missing Access-Control-Allow-Methods header") self.assertIn("Access-Control-Allow-Headers", response.headers, "Missing Access-Control-Allow-Headers header") # Check if Origin is allowed origin_header = response.headers.get("Access-Control-Allow-Origin") self.assertTrue(origin_header == "*" or origin_header == "http://example.com", f"Access-Control-Allow-Origin header has unexpected value: {origin_header}") print("✅ CORS headers are properly configured") # Test with actual request from different origin response = requests.get(f"{API_URL}/", headers={ "Origin": "http://example.com" }) self.assertEqual(response.status_code, 200, "GET request with Origin header failed") self.assertIn("Access-Control-Allow-Origin", response.headers, "Missing Access-Control-Allow-Origin header in actual request") print("✅ CORS is working for actual requests") def test_analytics_tracking(self): """Test analytics tracking endpoint""" print("\n--- Testing Analytics Tracking Endpoint ---") # Test with standard page view tracking tracking_data = { "page": "/latest-news", "event": "page_view", "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36", "timestamp": datetime.now().isoformat() } response = requests.post(f"{API_URL}/analytics/track", json=tracking_data) self.assertEqual(response.status_code, 200, "Failed to track analytics data") data = response.json() self.assertEqual(data["status"], "success", f"Analytics tracking failed with status: {data.get('status')}") self.assertEqual(data["message"], "Analytics data tracked successfully") print("✅ Analytics tracking endpoint working for page views") # Test with article view tracking article_tracking = { "page": "/articles/1", "event": "article_view", "article_id": 1, "article_title": "State Assembly Session Begins Today", "category": "Top News", "timestamp": datetime.now().isoformat() } response = requests.post(f"{API_URL}/analytics/track", json=article_tracking) self.assertEqual(response.status_code, 200, "Failed to track article view analytics") data = response.json() self.assertEqual(data["status"], "success") print("✅ Analytics tracking working for article views") # Test with component height change tracking height_change_tracking = { "page": "/", "event": "component_height_change", "component": "PoliticalNews", "old_height": 662, "new_height": 643, "timestamp": datetime.now().isoformat() } response = requests.post(f"{API_URL}/analytics/track", json=height_change_tracking) self.assertEqual(response.status_code, 200, "Failed to track component height change analytics") data = response.json() self.assertEqual(data["status"], "success") print("✅ Analytics tracking working for component height changes") if __name__ == "__main__": # Create a test suite suite = unittest.TestSuite() # Add all tests suite.addTest(ComprehensiveBackendTest("test_health_check")) suite.addTest(ComprehensiveBackendTest("test_database_connectivity")) suite.addTest(ComprehensiveBackendTest("test_articles_api_with_pagination")) suite.addTest(ComprehensiveBackendTest("test_categories_api")) suite.addTest(ComprehensiveBackendTest("test_movie_reviews_api")) suite.addTest(ComprehensiveBackendTest("test_featured_images_api")) suite.addTest(ComprehensiveBackendTest("test_article_view_count_increment")) suite.addTest(ComprehensiveBackendTest("test_cors_configuration")) suite.addTest(ComprehensiveBackendTest("test_analytics_tracking")) # Run the tests runner = unittest.TextTestRunner(verbosity=2) runner.run(suite)

#!/usr/bin/env python3 import requests import json import unittest import os import sys from datetime import datetime # Get the backend URL from the frontend .env file with open('/app/frontend/.env', 'r') as f: for line in f: if line.startswith('REACT_APP_BACKEND_URL='): BACKEND_URL = line.strip().split('=')[1].strip('"\'') break API_URL = f"{BACKEND_URL}/api" print(f"Testing API at: {API_URL}") class BlogCMSAPITest(unittest.TestCase): """Test suite for the Blog CMS API""" def setUp(self): """Set up test fixtures before each test method""" # Seed the database to ensure we have data to test with response = requests.post(f"{API_URL}/seed-database") self.assertEqual(response.status_code, 200, "Failed to seed database") print("Database seeded successfully") def test_health_check(self): """Test the health check endpoint""" print("\n--- Testing Health Check Endpoint ---") response = requests.get(f"{API_URL}/") self.assertEqual(response.status_code, 200, "Health check failed") data = response.json() self.assertEqual(data["message"], "Blog CMS API is running") self.assertEqual(data["status"], "healthy") print("✅ Health check endpoint working") def test_get_categories(self): """Test getting all categories""" print("\n--- Testing GET Categories Endpoint ---") response = requests.get(f"{API_URL}/categories") self.assertEqual(response.status_code, 200, "Failed to get categories") categories = response.json() self.assertIsInstance(categories, list, "Categories response is not a list") self.assertGreater(len(categories), 0, "No categories returned") # Check category structure category = categories[0] self.assertIn("id", category) self.assertIn("name", category) self.assertIn("slug", category) self.assertIn("description", category) self.assertIn("created_at", category) print(f"✅ GET categories endpoint working, returned {len(categories)} categories") # Test pagination response = requests.get(f"{API_URL}/categories?skip=2&limit=3") self.assertEqual(response.status_code, 200) paginated_categories = response.json() self.assertLessEqual(len(paginated_categories), 3, "Pagination limit not working") print("✅ Categories pagination working") def test_create_category(self): """Test creating a new category""" print("\n--- Testing POST Categories Endpoint ---") new_category = { "name": "Test Category", "slug": "test-category", "description": "This is a test category" } response = requests.post(f"{API_URL}/categories", json=new_category) self.assertEqual(response.status_code, 200, "Failed to create category") created_category = response.json() self.assertEqual(created_category["name"], new_category["name"]) self.assertEqual(created_category["slug"], new_category["slug"]) self.assertEqual(created_category["description"], new_category["description"]) print("✅ POST categories endpoint working") # Test duplicate slug error response = requests.post(f"{API_URL}/categories", json=new_category) self.assertEqual(response.status_code, 400, "Duplicate slug validation failed") print("✅ Category duplicate slug validation working") def test_get_articles(self): """Test getting all articles""" print("\n--- Testing GET Articles Endpoint ---") response = requests.get(f"{API_URL}/articles") self.assertEqual(response.status_code, 200, "Failed to get articles") articles = response.json() self.assertIsInstance(articles, list, "Articles response is not a list") self.assertGreater(len(articles), 0, "No articles returned") # Check article structure article = articles[0] self.assertIn("id", article) self.assertIn("title", article) self.assertIn("summary", article) self.assertIn("image_url", article) self.assertIn("author", article) self.assertIn("published_at", article) self.assertIn("category", article) self.assertIn("view_count", article) print(f"✅ GET articles endpoint working, returned {len(articles)} articles") # Test pagination response = requests.get(f"{API_URL}/articles?skip=5&limit=10") self.assertEqual(response.status_code, 200) paginated_articles = response.json() self.assertLessEqual(len(paginated_articles), 10, "Pagination limit not working") print("✅ Articles pagination working") def test_get_articles_by_category(self): """Test getting articles by category slug""" print("\n--- Testing GET Articles by Category Endpoint ---") # First get a category slug response = requests.get(f"{API_URL}/categories") categories = response.json() category_slug = categories[0]["slug"] # Get articles for this category response = requests.get(f"{API_URL}/articles/category/{category_slug}") self.assertEqual(response.status_code, 200, f"Failed to get articles for category {category_slug}") articles = response.json() self.assertIsInstance(articles, list, "Category articles response is not a list") print(f"✅ GET articles by category endpoint working, returned {len(articles)} articles for category '{category_slug}'") # Test with invalid category slug response = requests.get(f"{API_URL}/articles/category/invalid-category-slug") self.assertEqual(response.status_code, 200, "Invalid category should return empty list, not error") articles = response.json() self.assertEqual(len(articles), 0, "Invalid category should return empty list") print("✅ Articles by invalid category returns empty list") def test_get_most_read_articles(self): """Test getting most read articles""" print("\n--- Testing GET Most Read Articles Endpoint ---") response = requests.get(f"{API_URL}/articles/most-read") self.assertEqual(response.status_code, 200, "Failed to get most read articles") articles = response.json() self.assertIsInstance(articles, list, "Most read articles response is not a list") self.assertGreater(len(articles), 0, "No most read articles returned") # Check if articles are sorted by view_count in descending order if len(articles) > 1: self.assertGreaterEqual(articles[0]["view_count"], articles[1]["view_count"], "Most read articles not sorted by view count") print(f"✅ GET most read articles endpoint working, returned {len(articles)} articles") # Test limit parameter response = requests.get(f"{API_URL}/articles/most-read?limit=5") self.assertEqual(response.status_code, 200) limited_articles = response.json() self.assertLessEqual(len(limited_articles), 5, "Limit parameter not working") print("✅ Most read articles limit parameter working") def test_get_featured_article(self): """Test getting featured article""" print("\n--- Testing GET Featured Article Endpoint ---") response = requests.get(f"{API_URL}/articles/featured") # If there's a featured article, check its structure if response.status_code == 200: article = response.json() self.assertIn("id", article) self.assertIn("title", article) self.assertIn("content", article) self.assertIn("summary", article) self.assertIn("image_url", article) self.assertIn("author", article) self.assertIn("is_featured", article) self.assertTrue(article["is_featured"], "Featured article is_featured flag is not True") print("✅ GET featured article endpoint working") elif response.status_code == 404: # This is also acceptable if no featured article exists print("⚠️ No featured article found (404 response)") else: self.fail(f"Unexpected status code {response.status_code} for featured article") def test_get_article_by_id(self): """Test getting article by ID and view count increment""" print("\n--- Testing GET Article by ID Endpoint ---") # First get an article ID response = requests.get(f"{API_URL}/articles") articles = response.json() article_id = articles[0]["id"] # Get initial view count initial_view_count = articles[0]["view_count"] # Get the article by ID response = requests.get(f"{API_URL}/articles/{article_id}") self.assertEqual(response.status_code, 200, f"Failed to get article with ID {article_id}") article = response.json() self.assertEqual(article["id"], article_id) self.assertIn("content", article) # Full article should have content print(f"✅ GET article by ID endpoint working for article ID {article_id}") # Get the article again to check if view count incremented response = requests.get(f"{API_URL}/articles/{article_id}") self.assertEqual(response.status_code, 200) article_again = response.json() self.assertEqual(article_again["view_count"], initial_view_count + 2, "View count did not increment correctly") print("✅ Article view count increment working") # Test with invalid article ID response = requests.get(f"{API_URL}/articles/9999") self.assertEqual(response.status_code, 404, "Invalid article ID should return 404") print("✅ Invalid article ID returns 404") def test_create_article(self): """Test creating a new article""" print("\n--- Testing POST Articles Endpoint ---") # First get a category ID response = requests.get(f"{API_URL}/categories") categories = response.json() category_id = categories[0]["id"] new_article = { "title": "Test Article", "content": "This is a test article content with detailed information.", "summary": "This is a test article summary.", "image_url": "https://example.com/test-image.jpg", "author": "Test Author", "is_published": True, "is_featured": False, "category_id": category_id } response = requests.post(f"{API_URL}/articles", json=new_article) self.assertEqual(response.status_code, 200, "Failed to create article") created_article = response.json() self.assertEqual(created_article["title"], new_article["title"]) self.assertEqual(created_article["content"], new_article["content"]) self.assertEqual(created_article["summary"], new_article["summary"]) self.assertEqual(created_article["category_id"], new_article["category_id"]) print("✅ POST articles endpoint working") def test_get_movie_reviews(self): """Test getting all movie reviews""" print("\n--- Testing GET Movie Reviews Endpoint ---") response = requests.get(f"{API_URL}/movie-reviews") self.assertEqual(response.status_code, 200, "Failed to get movie reviews") reviews = response.json() self.assertIsInstance(reviews, list, "Movie reviews response is not a list") self.assertGreater(len(reviews), 0, "No movie reviews returned") # Check review structure review = reviews[0] self.assertIn("id", review) self.assertIn("title", review) self.assertIn("rating", review) self.assertIn("image_url", review) self.assertIn("created_at", review) print(f"✅ GET movie reviews endpoint working, returned {len(reviews)} reviews") # Test pagination response = requests.get(f"{API_URL}/movie-reviews?skip=1&limit=2") self.assertEqual(response.status_code, 200) paginated_reviews = response.json() self.assertLessEqual(len(paginated_reviews), 2, "Pagination limit not working") print("✅ Movie reviews pagination working") def test_get_movie_review_by_id(self): """Test getting movie review by ID""" print("\n--- Testing GET Movie Review by ID Endpoint ---") # First get a review ID response = requests.get(f"{API_URL}/movie-reviews") reviews = response.json() review_id = reviews[0]["id"] # Get the review by ID response = requests.get(f"{API_URL}/movie-reviews/{review_id}") self.assertEqual(response.status_code, 200, f"Failed to get movie review with ID {review_id}") review = response.json() self.assertEqual(review["id"], review_id) self.assertIn("content", review) # Full review should have content self.assertIn("director", review) self.assertIn("cast", review) self.assertIn("genre", review) print(f"✅ GET movie review by ID endpoint working for review ID {review_id}") # Test with invalid review ID response = requests.get(f"{API_URL}/movie-reviews/9999") self.assertEqual(response.status_code, 404, "Invalid review ID should return 404") print("✅ Invalid movie review ID returns 404") def test_create_movie_review(self): """Test creating a new movie review""" print("\n--- Testing POST Movie Reviews Endpoint ---") new_review = { "title": "Test Movie Review", "rating": 4.2, "content": "This is a test movie review with detailed critique.", "image_url": "https://example.com/test-movie.jpg", "director": "Test Director", "cast": "Actor 1, Actor 2, Actor 3", "genre": "Action/Drama", "reviewer": "Test Reviewer", "is_published": True } response = requests.post(f"{API_URL}/movie-reviews", json=new_review) self.assertEqual(response.status_code, 200, "Failed to create movie review") created_review = response.json() self.assertEqual(created_review["title"], new_review["title"]) self.assertEqual(created_review["rating"], new_review["rating"]) self.assertEqual(created_review["content"], new_review["content"]) self.assertEqual(created_review["director"], new_review["director"]) print("✅ POST movie reviews endpoint working") def test_get_featured_images(self): """Test getting featured images""" print("\n--- Testing GET Featured Images Endpoint ---") response = requests.get(f"{API_URL}/featured-images") self.assertEqual(response.status_code, 200, "Failed to get featured images") images = response.json() self.assertIsInstance(images, list, "Featured images response is not a list") self.assertGreater(len(images), 0, "No featured images returned") # Check image structure image = images[0] self.assertIn("id", image) self.assertIn("title", image) self.assertIn("image_url", image) self.assertIn("link_url", image) self.assertIn("order_index", image) self.assertIn("is_active", image) print(f"✅ GET featured images endpoint working, returned {len(images)} images") # Test limit parameter response = requests.get(f"{API_URL}/featured-images?limit=3") self.assertEqual(response.status_code, 200) limited_images = response.json() self.assertLessEqual(len(limited_images), 3, "Limit parameter not working") print("✅ Featured images limit parameter working") def test_create_featured_image(self): """Test creating a new featured image""" print("\n--- Testing POST Featured Images Endpoint ---") new_image = { "title": "Test Featured Image", "image_url": "https://example.com/test-featured.jpg", "link_url": "/articles/1", "description": "This is a test featured image", "order_index": 10, "is_active": True } response = requests.post(f"{API_URL}/featured-images", json=new_image) self.assertEqual(response.status_code, 200, "Failed to create featured image") created_image = response.json() self.assertEqual(created_image["title"], new_image["title"]) self.assertEqual(created_image["image_url"], new_image["image_url"]) self.assertEqual(created_image["link_url"], new_image["link_url"]) self.assertEqual(created_image["order_index"], new_image["order_index"]) print("✅ POST featured images endpoint working") def test_cors_headers(self): """Test CORS headers are properly set""" print("\n--- Testing CORS Headers ---") response = requests.options(f"{API_URL}/", headers={ "Origin": "http://example.com", "Access-Control-Request-Method": "GET" }) self.assertEqual(response.status_code, 200, "OPTIONS request failed") self.assertIn("Access-Control-Allow-Origin", response.headers) # The server might reflect the Origin header instead of using wildcard "*" self.assertIn(response.headers["Access-Control-Allow-Origin"], ["*", "http://example.com"]) self.assertIn("Access-Control-Allow-Methods", response.headers) print("✅ CORS headers are properly set") def test_analytics_tracking(self): """Test analytics tracking endpoint""" print("\n--- Testing Analytics Tracking Endpoint ---") tracking_data = { "page": "/vertical-gallery/1", "event": "page_view", "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36", "timestamp": datetime.now().isoformat() } response = requests.post(f"{API_URL}/analytics/track", json=tracking_data) self.assertEqual(response.status_code, 200, "Failed to track analytics data") data = response.json() self.assertEqual(data["status"], "success") self.assertEqual(data["message"], "Analytics data tracked successfully") self.assertIn("timestamp", data) print("✅ Analytics tracking endpoint working") # Test with vertical gallery specific tracking vertical_gallery_tracking = { "page": "/vertical-gallery/1", "event": "vertical_gallery_view", "article_id": 1, "article_title": "Profile: Young Entrepreneur's Success Journey", "category": "TravelPics", "timestamp": datetime.now().isoformat() } response = requests.post(f"{API_URL}/analytics/track", json=vertical_gallery_tracking) self.assertEqual(response.status_code, 200, "Failed to track vertical gallery analytics") data = response.json() self.assertEqual(data["status"], "success") print("✅ Vertical gallery analytics tracking working") def test_vertical_gallery_support(self): """Test backend support for vertical gallery pages""" print("\n--- Testing Vertical Gallery Support ---") # First, get all articles to find the TravelPics category article response = requests.get(f"{API_URL}/articles") self.assertEqual(response.status_code, 200, "Failed to get articles") articles = response.json() # Look for articles in the TravelPics category or with "Entrepreneur" in the title travel_article_id = None for article in articles: if article["category"] == "TravelPics" or "Entrepreneur" in article["title"]: travel_article_id = article["id"] break # If we didn't find a specific article, use the first one if not travel_article_id and articles: travel_article_id = articles[0]["id"] self.assertIsNotNone(travel_article_id, "No articles found to test vertical gallery") # Get the specific article that would be used for vertical gallery response = requests.get(f"{API_URL}/articles/{travel_article_id}") self.assertEqual(response.status_code, 200, f"Failed to get article with ID {travel_article_id}") article = response.json() # Verify the article has the necessary fields for vertical gallery display self.assertIn("id", article) self.assertIn("title", article) self.assertIn("content", article) self.assertIn("image_url", article) print(f"✅ Article retrieval for vertical gallery working with article ID {travel_article_id}") # Test analytics tracking for vertical gallery tracking_data = { "page": f"/vertical-gallery/{travel_article_id}", "event": "vertical_gallery_view", "article_id": travel_article_id, "timestamp": datetime.now().isoformat() } response = requests.post(f"{API_URL}/analytics/track", json=tracking_data) self.assertEqual(response.status_code, 200, "Failed to track vertical gallery view") print("✅ Vertical gallery view tracking working") def test_national_tab_top_stories_implementation(self): """Test National Tab implementation in Top Stories section""" print("\n--- Testing National Tab Top Stories Implementation ---") # Test 1: Database Categories Verification print("\n1. Testing Database Categories") response = requests.get(f"{API_URL}/categories") self.assertEqual(response.status_code, 200, "Failed to get categories") categories = response.json() # Check for required categories category_slugs = [cat["slug"] for cat in categories] self.assertIn("top-stories", category_slugs, "top-stories category not found in database") self.assertIn("national-top-stories", category_slugs, "national-top-stories category not found in database") # Get category details top_stories_cat = next((cat for cat in categories if cat["slug"] == "top-stories"), None) national_top_stories_cat = next((cat for cat in categories if cat["slug"] == "national-top-stories"), None) self.assertIsNotNone(top_stories_cat, "top-stories category details not found") self.assertIsNotNone(national_top_stories_cat, "national-top-stories category details not found") self.assertEqual(top_stories_cat["name"], "Top Stories") self.assertEqual(national_top_stories_cat["name"], "National Top Stories") print("✅ Database categories verified - both 'top-stories' and 'national-top-stories' exist") print(f" - Top Stories: {top_stories_cat['name']} (slug: {top_stories_cat['slug']})") print(f" - National Top Stories: {national_top_stories_cat['name']} (slug: {national_top_stories_cat['slug']})") # Test 2: API Endpoint Testing print("\n2. Testing /api/articles/sections/top-stories Endpoint") response = requests.get(f"{API_URL}/articles/sections/top-stories") self.assertEqual(response.status_code, 200, "Failed to get top stories section data") data = response.json() self.assertIsInstance(data, dict, "Top stories response should be a dictionary") # Verify response structure self.assertIn("top_stories", data, "Response missing 'top_stories' array") self.assertIn("national", data, "Response missing 'national' array") top_stories_articles = data["top_stories"] national_articles = data["national"] self.assertIsInstance(top_stories_articles, list, "'top_stories' should be a list") self.assertIsInstance(national_articles, list, "'national' should be a list") print("✅ API endpoint structure verified - returns proper JSON with 'top_stories' and 'national' arrays") print(f" - Top Stories articles: {len(top_stories_articles)}") print(f" - National articles: {len(national_articles)}") # Test 3: Article Content Verification print("\n3. Testing Article Content and Fields") # Test top_stories articles if top_stories_articles: article = top_stories_articles[0] required_fields = ["id", "title", "summary", "image_url", "author", "category", "published_at"] for field in required_fields: self.assertIn(field, article, f"Missing required field '{field}' in top_stories article") self.assertIsInstance(article["id"], int, "Article ID should be integer") self.assertIsInstance(article["title"], str, "Article title should be string") self.assertIsInstance(article["summary"], str, "Article summary should be string") self.assertIsInstance(article["author"], str, "Article author should be string") print("✅ Top Stories articles have proper field structure") print(f" - Sample article: '{article['title']}' by {article['author']}") else: print("⚠️ No top_stories articles found - database may need seeding") # Test national articles if national_articles: article = national_articles[0] required_fields = ["id", "title", "summary", "image_url", "author", "category", "published_at"] for field in required_fields: self.assertIn(field, article, f"Missing required field '{field}' in national article") self.assertIsInstance(article["id"], int, "Article ID should be integer") self.assertIsInstance(article["title"], str, "Article title should be string") self.assertIsInstance(article["summary"], str, "Article summary should be string") self.assertIsInstance(article["author"], str, "Article author should be string") print("✅ National articles have proper field structure") print(f" - Sample article: '{article['title']}' by {article['author']}") else: print("⚠️ No national articles found - database may need seeding") # Test 4: Database Seeding Verification print("\n4. Testing Database Seeding for New Categories") # Check articles in top-stories category response = requests.get(f"{API_URL}/articles/category/top-stories") self.assertEqual(response.status_code, 200, "Failed to get top-stories category articles") top_stories_db_articles = response.json() # Check articles in national-top-stories category response = requests.get(f"{API_URL}/articles/category/national-top-stories") self.assertEqual(response.status_code, 200, "Failed to get national-top-stories category articles") national_db_articles = response.json() self.assertGreater(len(top_stories_db_articles), 0, "No articles found in top-stories category") self.assertGreater(len(national_db_articles), 0, "No articles found in national-top-stories category") print("✅ Database seeding verified - both categories have sample articles") print(f" - top-stories category: {len(top_stories_db_articles)} articles") print(f" - national-top-stories category: {len(national_db_articles)} articles") # Verify article content quality if top_stories_db_articles: sample_article = top_stories_db_articles[0] self.assertGreater(len(sample_article["title"]), 10, "Article titles should be substantial") self.assertGreater(len(sample_article["summary"]), 20, "Article summaries should be substantial") print(f" - Sample top story: '{sample_article['title'][:50]}...'") if national_db_articles: sample_article = national_db_articles[0] self.assertGreater(len(sample_article["title"]), 10, "Article titles should be substantial") self.assertGreater(len(sample_article["summary"]), 20, "Article summaries should be substantial") print(f" - Sample national story: '{sample_article['title'][:50]}...'") # Test 5: CMS Integration Verification print("\n5. Testing CMS Integration for New Categories") # Test CMS config includes new categories response = requests.get(f"{API_URL}/cms/config") self.assertEqual(response.status_code, 200, "Failed to get CMS config") cms_config = response.json() self.assertIn("categories", cms_config, "CMS config missing categories") cms_categories = cms_config["categories"] cms_category_slugs = [cat["slug"] for cat in cms_categories] self.assertIn("top-stories", cms_category_slugs, "top-stories not available in CMS categories") self.assertIn("national-top-stories", cms_category_slugs, "national-top-stories not available in CMS categories") print("✅ CMS integration verified - new categories available for article creation") # Test CMS articles endpoint with category filtering response = requests.get(f"{API_URL}/cms/articles?category=top-stories") self.assertEqual(response.status_code, 200, "Failed to get CMS articles for top-stories category") cms_top_stories = response.json() response = requests.get(f"{API_URL}/cms/articles?category=national-top-stories") self.assertEqual(response.status_code, 200, "Failed to get CMS articles for national-top-stories category") cms_national_stories = response.json() print(f"✅ CMS category filtering working - top-stories: {len(cms_top_stories)}, national: {len(cms_national_stories)}") # Test 6: Error Handling print("\n6. Testing Error Handling") # Test with limit parameter response = requests.get(f"{API_URL}/articles/sections/top-stories?limit=2") self.assertEqual(response.status_code, 200, "API should handle limit parameter") limited_data = response.json() if limited_data["top_stories"]: self.assertLessEqual(len(limited_data["top_stories"]), 2, "Limit parameter not working for top_stories") if limited_data["national"]: self.assertLessEqual(len(limited_data["national"]), 2, "Limit parameter not working for national") print("✅ Error handling and parameter support working") print("\n🎉 NATIONAL TAB TOP STORIES IMPLEMENTATION TESTING COMPLETED SUCCESSFULLY!") print("✅ Database categories 'top-stories' and 'national-top-stories' exist and are properly configured") print("✅ API endpoint /api/articles/sections/top-stories returns correct JSON structure") print("✅ Both categories have sample articles with proper fields (id, title, summary, image_url, author, category, published_at)") print("✅ Database seeding works correctly with new categories and articles") print("✅ CMS integration allows creating articles in both 'top-stories' and 'national-top-stories' categories") print("✅ Backend article management for both categories is fully functional") print("✅ API endpoint functionality and response format are production-ready") print("✅ National Tab feature backend implementation is complete and working correctly") def test_gallery_post_functionality(self): """Test gallery post functionality and backend APIs as requested in review""" print("\n--- Testing Gallery Post Functionality and Backend APIs ---") # Test 1: Check Available Galleries - GET /api/galleries endpoint print("\n1. Testing GET /api/galleries endpoint") response = requests.get(f"{API_URL}/galleries") self.assertEqual(response.status_code, 200, "Failed to get galleries") galleries = response.json() self.assertIsInstance(galleries, list, "Galleries response should be a list") print(f"✅ GET /api/galleries working - found {len(galleries)} galleries") if len(galleries) == 0: print("⚠️ No galleries found in system - creating test gallery for testing") # Create a test gallery for testing purposes test_gallery = { "gallery_id": "test-gallery-001", "title": "Test Gallery for Backend Testing", "artists": ["Test Artist"], "images": [ { "url": "https://example.com/image1.jpg", "alt": "Test Image 1", "caption": "First test image" }, { "url": "https://example.com/image2.jpg", "alt": "Test Image 2", "caption": "Second test image" } ], "gallery_type": "vertical" } create_response = requests.post(f"{API_URL}/galleries", json=test_gallery) if create_response.status_code == 200: print("✅ Test gallery created successfully") # Refresh galleries list response = requests.get(f"{API_URL}/galleries") galleries = response.json() else: print(f"⚠️ Could not create test gallery: {create_response.status_code}") # Verify gallery structure if galleries: gallery = galleries[0] required_fields = ["id", "gallery_id", "title", "artists", "images", "gallery_type", "created_at", "updated_at"] for field in required_fields: self.assertIn(field, gallery, f"Gallery missing required field: {field}") # Verify images structure self.assertIsInstance(gallery["images"], list, "Gallery images should be a list") if gallery["images"]: image = gallery["images"][0] image_fields = ["url", "alt", "caption"] for field in image_fields: self.assertIn(field, image, f"Gallery image missing required field: {field}") print(f"✅ Gallery structure verified - sample gallery: '{gallery['title']}'") print(f" - Gallery ID: {gallery['gallery_id']}") print(f" - Artists: {gallery['artists']}") print(f" - Images count: {len(gallery['images'])}") print(f" - Gallery type: {gallery['gallery_type']}") # Test 2: Test Gallery API for articles with gallery data print("\n2. Testing GET /api/articles/{id} for articles with gallery data") # First get all articles to find ones with gallery_id response = requests.get(f"{API_URL}/articles") self.assertEqual(response.status_code, 200, "Failed to get articles") articles = response.json() gallery_articles = [] for article in articles: # Check if article has gallery information in the response if "gallery" in article and article["gallery"] is not None: gallery_articles.append(article) print(f"✅ Found {len(gallery_articles)} articles with gallery data") if len(gallery_articles) == 0: print("⚠️ No articles with gallery data found - checking individual articles") # Test a few individual articles to see if they have gallery data test_article_ids = [1, 2, 3, 4, 5] if len(articles) >= 5 else [article["id"] for article in articles[:3]] for article_id in test_article_ids: response = requests.get(f"{API_URL}/articles/{article_id}") if response.status_code == 200: article = response.json() if "gallery" in article and article["gallery"] is not None: gallery_articles.append(article) print(f"✅ Found gallery data in article {article_id}: '{article['title']}'") # Test 3: Test Gallery Post Backend Integration print("\n3. Testing Gallery Post Backend Integration") if gallery_articles: for gallery_article in gallery_articles[:3]: # Test up to 3 gallery articles article_id = gallery_article["id"] # Get full article details response = requests.get(f"{API_URL}/articles/{article_id}") self.assertEqual(response.status_code, 200, f"Failed to get article {article_id}") article = response.json() print(f"\n Testing article {article_id}: '{article['title']}'") # Verify article has gallery_id field (if present in backend) if "gallery_id" in article: self.assertIsNotNone(article["gallery_id"], f"Article {article_id} has null gallery_id") print(f" ✅ Article has gallery_id: {article['gallery_id']}") # Verify article has gallery object with images array if "gallery" in article and article["gallery"] is not None: gallery_data = article["gallery"] # Check gallery structure self.assertIn("images", gallery_data, f"Gallery data missing images array for article {article_id}") self.assertIsInstance(gallery_data["images"], list, f"Gallery images should be a list for article {article_id}") print(f" ✅ Article has gallery object with {len(gallery_data['images'])} images") # Verify each image has required fields for i, image in enumerate(gallery_data["images"]): required_image_fields = ["url", "alt", "caption"] for field in required_image_fields: self.assertIn(field, image, f"Image {i} missing {field} field in article {article_id}") # Verify field types self.assertIsInstance(image["url"], str, f"Image {i} url should be string in article {article_id}") self.assertIsInstance(image["alt"], str, f"Image {i} alt should be string in article {article_id}") self.assertIsInstance(image["caption"], str, f"Image {i} caption should be string in article {article_id}") print(f" ✅ All images have required fields (url, alt, caption)") # Check if gallery data matches frontend expectations if "gallery_id" in gallery_data: print(f" ✅ Gallery has gallery_id: {gallery_data['gallery_id']}") if "gallery_title" in gallery_data: print(f" ✅ Gallery has title: {gallery_data['gallery_title']}") else: print(f" ⚠️ Article {article_id} does not have gallery object in response") else: print("⚠️ No articles with gallery data found for integration testing") # Test 4: Backend API Validation for Frontend GalleryPost Component print("\n4. Testing Backend API Validation for Frontend GalleryPost Component") # Test gallery endpoints that frontend might use gallery_endpoints_to_test = [ "/galleries", "/galleries?limit=10", "/galleries?limit=20" ] for endpoint in gallery_endpoints_to_test: response = requests.get(f"{API_URL}{endpoint}") self.assertEqual(response.status_code, 200, f"Gallery endpoint {endpoint} failed") data = response.json() self.assertIsInstance(data, list, f"Gallery endpoint {endpoint} should return list") print(f" ✅ {endpoint} working - returned {len(data)} galleries") # Test individual gallery retrieval if galleries exist if galleries: test_gallery_id = galleries[0]["id"] response = requests.get(f"{API_URL}/galleries/{test_gallery_id}") self.assertEqual(response.status_code, 200, f"Failed to get individual gallery {test_gallery_id}") gallery_detail = response.json() # Verify detailed gallery structure self.assertIn("images", gallery_detail, "Individual gallery missing images") self.assertIn("title", gallery_detail, "Individual gallery missing title") self.assertIn("artists", gallery_detail, "Individual gallery missing artists") print(f" ✅ Individual gallery retrieval working for gallery {test_gallery_id}") # Test 5: Verify Data Structure Compatibility with Frontend print("\n5. Testing Data Structure Compatibility with Frontend GalleryPost Component") if galleries: sample_gallery = galleries[0] # Check if data structure matches what frontend GalleryPost expects frontend_required_fields = { "id": int, "title": str, "images": list, "gallery_type": str } for field, expected_type in frontend_required_fields.items(): self.assertIn(field, sample_gallery, f"Gallery missing frontend required field: {field}") if sample_gallery[field] is not None: self.assertIsInstance(sample_gallery[field], expected_type, f"Gallery field {field} should be {expected_type.__name__}") # Check image slider compatibility if sample_gallery["images"]: sample_image = sample_gallery["images"][0] image_required_fields = { "url": str, "alt": str, "caption": str } for field, expected_type in image_required_fields.items(): self.assertIn(field, sample_image, f"Image missing frontend required field: {field}") self.assertIsInstance(sample_image[field], expected_type, f"Image field {field} should be {expected_type.__name__}") print(f" ✅ Gallery data structure compatible with frontend image slider") print(f" ✅ Sample image URL: {sample_image['url']}") print(f" ✅ Sample image alt: {sample_image['alt']}") print(f" ✅ Sample image caption: {sample_image['caption']}") # Test 6: Performance and Error Handling print("\n6. Testing Performance and Error Handling") # Test invalid gallery ID response = requests.get(f"{API_URL}/galleries/99999") self.assertEqual(response.status_code, 404, "Invalid gallery ID should return 404") print(" ✅ Invalid gallery ID returns 404") # Test invalid article ID response = requests.get(f"{API_URL}/articles/99999") self.assertEqual(response.status_code, 404, "Invalid article ID should return 404") print(" ✅ Invalid article ID returns 404") # Test gallery pagination response = requests.get(f"{API_URL}/galleries?limit=5") self.assertEqual(response.status_code, 200, "Gallery pagination failed") paginated_galleries = response.json() self.assertLessEqual(len(paginated_galleries), 5, "Gallery pagination limit not working") print(" ✅ Gallery pagination working") # Test 7: Summary and Recommendations print("\n7. Gallery Post Functionality Test Summary") total_galleries = len(galleries) total_gallery_articles = len(gallery_articles) print(f"\n📊 GALLERY POST FUNCTIONALITY TEST RESULTS:") print(f" - Total galleries in system: {total_galleries}") print(f" - Articles with gallery data: {total_gallery_articles}") print(f" - Gallery API endpoints: ✅ Working") print(f" - Article gallery integration: {'✅ Working' if total_gallery_articles > 0 else '⚠️ Limited data'}") print(f" - Frontend compatibility: ✅ Data structure matches expectations") print(f" - Error handling: ✅ Proper 404 responses") print(f" - Performance: ✅ Pagination and limits working") if total_galleries > 0 and total_gallery_articles > 0: print(f"\n🎉 GALLERY POST FUNCTIONALITY TESTING COMPLETED SUCCESSFULLY!") print(f"✅ Backend is properly serving gallery data for frontend GalleryPost component") print(f"✅ Gallery data structure matches frontend image slider requirements") print(f"✅ All required fields (url, alt, caption) present in gallery images") print(f"✅ Gallery API endpoints working correctly") print(f"✅ Article-gallery integration functional") else: print(f"\n⚠️ GALLERY POST FUNCTIONALITY TESTING COMPLETED WITH LIMITATIONS:") if total_galleries == 0: print(f"⚠️ No galleries found in system - may need data seeding") if total_gallery_articles == 0: print(f"⚠️ No articles with gallery data found - may need gallery-article associations") print(f"✅ Backend API structure is correct and ready for gallery data") def test_authentication_system(self): """Test comprehensive authentication system""" print("\n--- Testing Authentication System ---") # Test 1: User Registration print("\n1. Testing User Registration") new_user = { "username": "testuser", "password": "testpass123", "confirm_password": "testpass123" } response = requests.post(f"{API_URL}/auth/register", json=new_user) self.assertEqual(response.status_code, 200, "Failed to register new user") registration_data = response.json() self.assertEqual(registration_data["username"], new_user["username"]) self.assertEqual(registration_data["roles"], ["Viewer"]) print("✅ User registration working - default Viewer role assigned") # Test duplicate username validation response = requests.post(f"{API_URL}/auth/register", json=new_user) self.assertEqual(response.status_code, 400, "Duplicate username validation failed") print("✅ Duplicate username validation working") # Test password mismatch validation mismatched_user = { "username": "testuser2", "password": "testpass123", "confirm_password": "differentpass" } response = requests.post(f"{API_URL}/auth/register", json=mismatched_user) self.assertEqual(response.status_code, 400, "Password mismatch validation failed") print("✅ Password mismatch validation working") # Test 2: User Login print("\n2. Testing User Login") login_data = { "username": "testuser", "password": "testpass123" } response = requests.post(f"{API_URL}/auth/login", data=login_data) self.assertEqual(response.status_code, 200, "Failed to login user") login_response = response.json() self.assertIn("access_token", login_response) self.assertEqual(login_response["token_type"], "bearer") self.assertIn("user", login_response) self.assertEqual(login_response["user"]["username"], "testuser") self.assertEqual(login_response["user"]["roles"], ["Viewer"]) user_token = login_response["access_token"] print("✅ User login working - JWT token generated") # Test invalid credentials invalid_login = { "username": "testuser", "password": "wrongpassword" } response = requests.post(f"{API_URL}/auth/login", data=invalid_login) self.assertEqual(response.status_code, 401, "Invalid credentials should return 401") print("✅ Invalid credentials properly rejected") # Test 3: Admin Login print("\n3. Testing Admin Login") admin_login = { "username": "admin", "password": "admin123" } response = requests.post(f"{API_URL}/auth/login", data=admin_login) self.assertEqual(response.status_code, 200, "Failed to login admin") admin_response = response.json() self.assertIn("access_token", admin_response) self.assertEqual(admin_response["user"]["username"], "admin") self.assertIn("Admin", admin_response["user"]["roles"]) admin_token = admin_response["access_token"] print("✅ Admin login working - Admin role confirmed") # Test 4: Current User Endpoint print("\n4. Testing Current User Endpoint") headers = {"Authorization": f"Bearer {user_token}"} response = requests.get(f"{API_URL}/auth/me", headers=headers) self.assertEqual(response.status_code, 200, "Failed to get current user info") user_info = response.json() self.assertEqual(user_info["username"], "testuser") self.assertEqual(user_info["roles"], ["Viewer"]) self.assertTrue(user_info["is_active"]) print("✅ Current user endpoint working") # Test unauthorized access response = requests.get(f"{API_URL}/auth/me") self.assertEqual(response.status_code, 401, "Unauthorized access should return 401") print("✅ Unauthorized access properly rejected") # Test invalid token invalid_headers = {"Authorization": "Bearer invalid_token"} response = requests.get(f"{API_URL}/auth/me", headers=invalid_headers) self.assertEqual(response.status_code, 401, "Invalid token should return 401") print("✅ Invalid token properly rejected") # Test 5: Admin Endpoints print("\n5. Testing Admin Endpoints") admin_headers = {"Authorization": f"Bearer {admin_token}"} # Get all users (admin only) response = requests.get(f"{API_URL}/auth/users", headers=admin_headers) self.assertEqual(response.status_code, 200, "Failed to get users list") users_list = response.json() self.assertIsInstance(users_list, list) self.assertGreater(len(users_list), 0, "No users returned") print(f"✅ Get all users endpoint working - returned {len(users_list)} users") # Test non-admin access to admin endpoint response = requests.get(f"{API_URL}/auth/users", headers=headers) self.assertEqual(response.status_code, 403, "Non-admin should not access admin endpoints") print("✅ Admin endpoint protection working") # Update user role (admin only) role_update = ["Author"] response = requests.put(f"{API_URL}/auth/users/testuser/role", json=role_update, headers=admin_headers) self.assertEqual(response.status_code, 200, "Failed to update user role") print("✅ User role update working") # Verify role was updated response = requests.get(f"{API_URL}/auth/me", headers=headers) # Note: The token still has old roles, need to login again to get new token new_login_response = requests.post(f"{API_URL}/auth/login", data=login_data) new_token = new_login_response.json()["access_token"] new_headers = {"Authorization": f"Bearer {new_token}"} response = requests.get(f"{API_URL}/auth/me", headers=new_headers) updated_user = response.json() self.assertEqual(updated_user["roles"], ["Author"]) print("✅ Role update verified - user now has Author role") # Test invalid role update invalid_roles = ["InvalidRole"] response = requests.put(f"{API_URL}/auth/users/testuser/role", json=invalid_roles, headers=admin_headers) self.assertEqual(response.status_code, 400, "Invalid role should be rejected") print("✅ Invalid role validation working") # Test role update for non-existent user response = requests.put(f"{API_URL}/auth/users/nonexistentuser/role", json=["Viewer"], headers=admin_headers) self.assertEqual(response.status_code, 404, "Non-existent user should return 404") print("✅ Non-existent user role update returns 404") # Test 6: User Deletion print("\n6. Testing User Deletion") # Try to delete admin user (should fail) response = requests.delete(f"{API_URL}/auth/users/admin", headers=admin_headers) self.assertEqual(response.status_code, 400, "Admin user deletion should be prevented") print("✅ Admin user deletion protection working") # Delete test user response = requests.delete(f"{API_URL}/auth/users/testuser", headers=admin_headers) self.assertEqual(response.status_code, 200, "Failed to delete user") print("✅ User deletion working") # Verify user was deleted response = requests.get(f"{API_URL}/auth/me", headers=new_headers) self.assertEqual(response.status_code, 401, "Deleted user token should be invalid") print("✅ Deleted user token invalidation working") # Test deleting non-existent user response = requests.delete(f"{API_URL}/auth/users/nonexistentuser", headers=admin_headers) self.assertEqual(response.status_code, 404, "Non-existent user deletion should return 404") print("✅ Non-existent user deletion returns 404") print("\n🎉 COMPREHENSIVE AUTHENTICATION SYSTEM TESTING COMPLETED SUCCESSFULLY!") print("✅ All authentication endpoints working correctly") print("✅ JWT token generation and validation working") print("✅ Role-based access control functioning properly") print("✅ Admin user protection and management working") print("✅ Error handling and validation working correctly") print("✅ Authentication system is ready for AuthModal integration") def test_movie_release_management_system(self): """Test comprehensive movie release management system with language field migration""" print("\n--- Testing Movie Release Management System ---") # Test 1: Theater Release Creation with Language Field print("\n1. Testing Theater Release Creation with Language Field") # Test data for theater release theater_release_data = { "movie_name": "Pushpa 2: The Rule", "movie_banner": "Mythri Movie Makers", "language": "Telugu", "release_date": "2024-12-05", "created_by": "Admin User" } # Create theater release using form data (multipart/form-data) response = requests.post(f"{API_URL}/cms/theater-releases", data=theater_release_data) self.assertEqual(response.status_code, 200, f"Failed to create theater release: {response.text}") created_theater_release = response.json() self.assertEqual(created_theater_release["movie_name"], theater_release_data["movie_name"]) self.assertEqual(created_theater_release["movie_banner"], theater_release_data["movie_banner"]) self.assertEqual(created_theater_release["language"], theater_release_data["language"]) self.assertEqual(created_theater_release["created_by"], theater_release_data["created_by"]) self.assertIn("id", created_theater_release) self.assertIn("created_at", created_theater_release) theater_release_id = created_theater_release["id"] print(f"✅ Theater release created successfully with ID {theater_release_id}") print(f" - Movie: {created_theater_release['movie_name']}") print(f" - Language: {created_theater_release['language']}") print(f" - Banner: {created_theater_release['movie_banner']}") print(f" - Release Date: {created_theater_release['release_date']}") # Test 2: OTT Release Creation with Language Field print("\n2. Testing OTT Release Creation with Language Field") # Test data for OTT release ott_release_data = { "movie_name": "RRR", "ott_platform": "Netflix", "language": "Hindi", "release_date": "2024-12-10", "created_by": "Content Manager" } # Create OTT release using form data response = requests.post(f"{API_URL}/cms/ott-releases", data=ott_release_data) self.assertEqual(response.status_code, 200, f"Failed to create OTT release: {response.text}") created_ott_release = response.json() self.assertEqual(created_ott_release["movie_name"], ott_release_data["movie_name"]) self.assertEqual(created_ott_release["ott_platform"], ott_release_data["ott_platform"]) self.assertEqual(created_ott_release["language"], ott_release_data["language"]) self.assertEqual(created_ott_release["created_by"], ott_release_data["created_by"]) self.assertIn("id", created_ott_release) self.assertIn("created_at", created_ott_release) ott_release_id = created_ott_release["id"] print(f"✅ OTT release created successfully with ID {ott_release_id}") print(f" - Movie: {created_ott_release['movie_name']}") print(f" - Language: {created_ott_release['language']}") print(f" - Platform: {created_ott_release['ott_platform']}") print(f" - Release Date: {created_ott_release['release_date']}") # Test 3: Theater Release Retrieval with Language Field print("\n3. Testing Theater Release Retrieval with Language Field") # Get all theater releases response = requests.get(f"{API_URL}/cms/theater-releases") self.assertEqual(response.status_code, 200, "Failed to get theater releases") theater_releases = response.json() self.assertIsInstance(theater_releases, list, "Theater releases response should be a list") self.assertGreater(len(theater_releases), 0, "No theater releases found") # Verify language field is present in all releases for release in theater_releases: self.assertIn("language", release, "Language field missing from theater release") self.assertIsInstance(release["language"], str, "Language should be a string") self.assertIn("id", release) self.assertIn("movie_name", release) self.assertIn("movie_banner", release) self.assertIn("release_date", release) self.assertIn("created_by", release) self.assertIn("created_at", release) print(f"✅ Theater releases retrieval working - found {len(theater_releases)} releases") print(f" - All releases have language field") # Get specific theater release response = requests.get(f"{API_URL}/cms/theater-releases/{theater_release_id}") self.assertEqual(response.status_code, 200, f"Failed to get theater release {theater_release_id}") specific_theater_release = response.json() self.assertEqual(specific_theater_release["id"], theater_release_id) self.assertEqual(specific_theater_release["language"], "Telugu") print(f"✅ Specific theater release retrieval working with language field") # Test 4: OTT Release Retrieval with Language Field print("\n4. Testing OTT Release Retrieval with Language Field") # Get all OTT releases response = requests.get(f"{API_URL}/cms/ott-releases") self.assertEqual(response.status_code, 200, "Failed to get OTT releases") ott_releases = response.json() self.assertIsInstance(ott_releases, list, "OTT releases response should be a list") self.assertGreater(len(ott_releases), 0, "No OTT releases found") # Verify language field is present in all releases for release in ott_releases: self.assertIn("language", release, "Language field missing from OTT release") self.assertIsInstance(release["language"], str, "Language should be a string") self.assertIn("id", release) self.assertIn("movie_name", release) self.assertIn("ott_platform", release) self.assertIn("release_date", release) self.assertIn("created_by", release) self.assertIn("created_at", release) print(f"✅ OTT releases retrieval working - found {len(ott_releases)} releases") print(f" - All releases have language field") # Get specific OTT release response = requests.get(f"{API_URL}/cms/ott-releases/{ott_release_id}") self.assertEqual(response.status_code, 200, f"Failed to get OTT release {ott_release_id}") specific_ott_release = response.json() self.assertEqual(specific_ott_release["id"], ott_release_id) self.assertEqual(specific_ott_release["language"], "Hindi") print(f"✅ Specific OTT release retrieval working with language field") # Test 5: Homepage Release Data with Language Field print("\n5. Testing Homepage Release Data with Language Field") response = requests.get(f"{API_URL}/releases/theater-ott") self.assertEqual(response.status_code, 200, "Failed to get homepage release data") homepage_data = response.json() # Verify structure self.assertIn("theater", homepage_data, "Homepage data missing theater section") self.assertIn("ott", homepage_data, "Homepage data missing OTT section") theater_data = homepage_data["theater"] ott_data = homepage_data["ott"] self.assertIn("this_week", theater_data, "Theater data missing this_week section") self.assertIn("coming_soon", theater_data, "Theater data missing coming_soon section") self.assertIn("this_week", ott_data, "OTT data missing this_week section") self.assertIn("coming_soon", ott_data, "OTT data missing coming_soon section") # Check language field in theater releases all_theater_releases = theater_data["this_week"] + theater_data["coming_soon"] for release in all_theater_releases: self.assertIn("language", release, "Language field missing from homepage theater release") self.assertIn("movie_name", release) self.assertIn("movie_banner", release) self.assertIn("release_date", release) # Check language field in OTT releases all_ott_releases = ott_data["this_week"] + ott_data["coming_soon"] for release in all_ott_releases: self.assertIn("language", release, "Language field missing from homepage OTT release") self.assertIn("movie_name", release) self.assertIn("ott_platform", release) self.assertIn("release_date", release) print(f"✅ Homepage release data working with language field") print(f" - Theater releases: {len(all_theater_releases)} total") print(f" - OTT releases: {len(all_ott_releases)} total") print(f" - All releases include language field") # Test 6: Language Field Validation and Default Values print("\n6. Testing Language Field Validation and Default Values") # Test theater release with default language (should be Hindi) default_theater_data = { "movie_name": "Test Movie Default Lang", "movie_banner": "Test Banner", "release_date": "2024-12-15", "created_by": "Test User" # No language field - should default to Hindi } response = requests.post(f"{API_URL}/cms/theater-releases", data=default_theater_data) self.assertEqual(response.status_code, 200, "Failed to create theater release with default language") default_theater_release = response.json() self.assertEqual(default_theater_release["language"], "Hindi", "Default language should be Hindi") print(f"✅ Theater release default language working - defaults to 'Hindi'") # Test OTT release with default language default_ott_data = { "movie_name": "Test OTT Movie Default Lang", "ott_platform": "Amazon Prime", "release_date": "2024-12-20", "created_by": "Test User" # No language field - should default to Hindi } response = requests.post(f"{API_URL}/cms/ott-releases", data=default_ott_data) self.assertEqual(response.status_code, 200, "Failed to create OTT release with default language") default_ott_release = response.json() self.assertEqual(default_ott_release["language"], "Hindi", "Default language should be Hindi") print(f"✅ OTT release default language working - defaults to 'Hindi'") # Test 7: Update Operations with Language Field print("\n7. Testing Update Operations with Language Field") # Update theater release language update_theater_data = { "language": "Tamil" } response = requests.put(f"{API_URL}/cms/theater-releases/{theater_release_id}", data=update_theater_data) self.assertEqual(response.status_code, 200, "Failed to update theater release language") updated_theater = response.json() self.assertEqual(updated_theater["language"], "Tamil") print(f"✅ Theater release language update working") # Update OTT release language update_ott_data = { "language": "English" } response = requests.put(f"{API_URL}/cms/ott-releases/{ott_release_id}", data=update_ott_data) self.assertEqual(response.status_code, 200, "Failed to update OTT release language") updated_ott = response.json() self.assertEqual(updated_ott["language"], "English") print(f"✅ OTT release language update working") # Test 8: Error Handling and Edge Cases print("\n8. Testing Error Handling and Edge Cases") # Test invalid theater release data invalid_theater_data = { "movie_name": "", # Empty movie name "movie_banner": "Test Banner", "language": "Telugu", "release_date": "invalid-date", # Invalid date format "created_by": "Test User" } response = requests.post(f"{API_URL}/cms/theater-releases", data=invalid_theater_data) # Should handle validation errors gracefully print(f" - Invalid theater data response: {response.status_code}") # Test non-existent release retrieval response = requests.get(f"{API_URL}/cms/theater-releases/99999") self.assertEqual(response.status_code, 404, "Non-existent theater release should return 404") response = requests.get(f"{API_URL}/cms/ott-releases/99999") self.assertEqual(response.status_code, 404, "Non-existent OTT release should return 404") print(f"✅ Error handling working - 404 for non-existent releases") # Test 9: Database Schema Verification (Indirect) print("\n9. Testing Database Schema Verification (Indirect)") # The fact that we can create, read, update releases with language field # confirms that the database migration was successful print(f"✅ Database schema verification successful:") print(f" - theater_releases table has language column (confirmed by successful CRUD operations)") print(f" - ott_releases table has language column (confirmed by successful CRUD operations)") print(f" - Language field accepts string values and has default value 'Hindi'") print(f" - No 'no such column' errors encountered during testing") # Test 10: Multiple Language Support print("\n10. Testing Multiple Language Support") languages_to_test = ["Telugu", "Hindi", "Tamil", "English", "Kannada", "Malayalam"] for i, language in enumerate(languages_to_test): test_theater_data = { "movie_name": f"Test Movie {language}", "movie_banner": f"Test Banner {language}", "language": language, "release_date": "2024-12-25", "created_by": "Language Test User" } response = requests.post(f"{API_URL}/cms/theater-releases", data=test_theater_data) self.assertEqual(response.status_code, 200, f"Failed to create theater release in {language}") created_release = response.json() self.assertEqual(created_release["language"], language) print(f"✅ Multiple language support working - tested {len(languages_to_test)} languages") print(f" - Languages tested: {', '.join(languages_to_test)}") print("\n🎉 MOVIE RELEASE MANAGEMENT SYSTEM TESTING COMPLETED SUCCESSFULLY!") print("✅ Theater release creation working with language field") print("✅ OTT release creation working with language field") print("✅ Theater release retrieval includes language field") print("✅ OTT release retrieval includes language field") print("✅ Homepage release data includes language field") print("✅ Database migration successful - no 'no such column' errors") print("✅ Language field validation and default values working") print("✅ Update operations support language field") print("✅ Error handling working correctly") print("✅ Multiple language support confirmed") print("✅ CRITICAL ISSUE RESOLVED: Theater and OTT release creation now works without database errors") if __name__ == "__main__": # Create a test suite suite = unittest.TestSuite() # Add the gallery post functionality test as priority (as requested in review) suite.addTest(BlogCMSAPITest("test_gallery_post_functionality")) # Add other essential tests suite.addTest(BlogCMSAPITest("test_health_check")) suite.addTest(BlogCMSAPITest("test_get_categories")) suite.addTest(BlogCMSAPITest("test_get_articles")) suite.addTest(BlogCMSAPITest("test_get_articles_by_category")) suite.addTest(BlogCMSAPITest("test_get_article_by_id")) # Run the tests runner = unittest.TextTestRunner(verbosity=2) runner.run(suite)

#!/usr/bin/env python3 import requests import json import sys from datetime import datetime # Get the backend URL from the frontend .env file with open('/app/frontend/.env', 'r') as f: for line in f: if line.startswith('REACT_APP_BACKEND_URL='): BACKEND_URL = line.strip().split('=')[1].strip('"\'') break API_URL = f"{BACKEND_URL}/api" print(f"Testing API at: {API_URL}") def test_health_check(): """Test the health check endpoint""" print("\n--- Testing Health Check Endpoint ---") try: response = requests.get(f"{API_URL}/") if response.status_code == 200: data = response.json() if data.get("message") == "Blog CMS API is running" and data.get("status") == "healthy": print("✅ Health check endpoint working correctly") return True else: print(f"❌ Health check returned unexpected data: {data}") return False else: print(f"❌ Health check failed with status {response.status_code}: {response.text}") return False except Exception as e: print(f"❌ Health check failed with error: {e}") return False def test_database_seeding(): """Test database seeding functionality""" print("\n--- Testing Database Seeding ---") try: response = requests.post(f"{API_URL}/seed-database") if response.status_code == 200: data = response.json() if "Database seeded successfully" in data.get("message", ""): print("✅ Database seeding working correctly") return True else: print(f"❌ Database seeding returned unexpected message: {data}") return False else: print(f"❌ Database seeding failed with status {response.status_code}: {response.text}") return False except Exception as e: print(f"❌ Database seeding failed with error: {e}") return False def test_categories_api(): """Test categories API""" print("\n--- Testing Categories API ---") try: # Test GET /categories response = requests.get(f"{API_URL}/categories") if response.status_code == 200: categories = response.json() if isinstance(categories, list) and len(categories) >= 10: print(f"✅ Categories API working correctly - Found {len(categories)} categories") return True else: print(f"❌ Categories API returned unexpected data: {len(categories) if isinstance(categories, list) else 'not a list'}") return False else: print(f"❌ Categories API failed with status {response.status_code}: {response.text}") return False except Exception as e: print(f"❌ Categories API failed with error: {e}") return False def test_articles_api(): """Test articles API""" print("\n--- Testing Articles API ---") try: # Test GET /articles response = requests.get(f"{API_URL}/articles") if response.status_code == 200: articles = response.json() if isinstance(articles, list) and len(articles) >= 20: print(f"✅ Articles API working correctly - Found {len(articles)} articles") # Test individual article endpoint if articles: article_id = articles[0]["id"] response = requests.get(f"{API_URL}/articles/{article_id}") if response.status_code == 200: article = response.json() if "content" in article: print("✅ Individual article endpoint working correctly") return True else: print("❌ Individual article missing content field") return False else: print(f"❌ Individual article endpoint failed with status {response.status_code}") return False return True else: print(f"❌ Articles API returned unexpected data: {len(articles) if isinstance(articles, list) else 'not a list'}") return False else: print(f"❌ Articles API failed with status {response.status_code}: {response.text}") return False except Exception as e: print(f"❌ Articles API failed with error: {e}") return False def test_movie_reviews_api(): """Test movie reviews API""" print("\n--- Testing Movie Reviews API ---") try: response = requests.get(f"{API_URL}/movie-reviews") if response.status_code == 200: reviews = response.json() if isinstance(reviews, list) and len(reviews) >= 3: print(f"✅ Movie Reviews API working correctly - Found {len(reviews)} reviews") return True else: print(f"❌ Movie Reviews API returned unexpected data: {len(reviews) if isinstance(reviews, list) else 'not a list'}") return False else: print(f"❌ Movie Reviews API failed with status {response.status_code}: {response.text}") return False except Exception as e: print(f"❌ Movie Reviews API failed with error: {e}") return False def test_featured_images_api(): """Test featured images API""" print("\n--- Testing Featured Images API ---") try: response = requests.get(f"{API_URL}/featured-images") if response.status_code == 200: images = response.json() if isinstance(images, list) and len(images) >= 5: print(f"✅ Featured Images API working correctly - Found {len(images)} images") return True else: print(f"❌ Featured Images API returned unexpected data: {len(images) if isinstance(images, list) else 'not a list'}") return False else: print(f"❌ Featured Images API failed with status {response.status_code}: {response.text}") return False except Exception as e: print(f"❌ Featured Images API failed with error: {e}") return False def test_cors_configuration(): """Test CORS configuration""" print("\n--- Testing CORS Configuration ---") try: response = requests.get(f"{API_URL}/", headers={ "Origin": "http://example.com" }) if response.status_code == 200: if "Access-Control-Allow-Origin" in response.headers: print("✅ CORS configuration working correctly") return True else: print("❌ CORS headers missing") return False else: print(f"❌ CORS test failed with status {response.status_code}") return False except Exception as e: print(f"❌ CORS test failed with error: {e}") return False def test_authentication_basic(): """Test basic authentication functionality""" print("\n--- Testing Basic Authentication ---") try: # Test admin login login_data = { "username": "admin", "password": "admin123" } response = requests.post(f"{API_URL}/auth/login", data=login_data) if response.status_code == 200: data = response.json() if "access_token" in data and "user" in data: print("✅ Admin login working correctly") return True else: print(f"❌ Admin login returned unexpected data: {data}") return False else: print(f"❌ Admin login failed with status {response.status_code}: {response.text}") return False except Exception as e: print(f"❌ Admin login failed with error: {e}") return False def main(): """Run all backend verification tests""" print("="*60) print("BACKEND VERIFICATION TEST SUITE") print("="*60) tests = [ ("Health Check", test_health_check), ("Database Seeding", test_database_seeding), ("Categories API", test_categories_api), ("Articles API", test_articles_api), ("Movie Reviews API", test_movie_reviews_api), ("Featured Images API", test_featured_images_api), ("CORS Configuration", test_cors_configuration), ("Basic Authentication", test_authentication_basic), ] passed = 0 failed = 0 for test_name, test_func in tests: try: if test_func(): passed += 1 else: failed += 1 except Exception as e: print(f"❌ {test_name} failed with exception: {e}") failed += 1 print("\n" + "="*60) print("BACKEND VERIFICATION TEST SUMMARY") print("="*60) print(f"Total tests: {len(tests)}") print(f"Passed: {passed}") print(f"Failed: {failed}") if failed == 0: print("\n🎉 ALL BACKEND TESTS PASSED!") print("Backend functionality is working correctly after frontend section swap fix.") return True else: print(f"\n❌ {failed} BACKEND TESTS FAILED!") print("Some backend functionality may have issues.") return False if __name__ == "__main__": success = main() sys.exit(0 if success else 1)

#!/usr/bin/env python3 import requests import json import unittest import os import sys from datetime import datetime import time # Get the backend URL from the frontend .env file with open('/app/frontend/.env', 'r') as f: for line in f: if line.startswith('REACT_APP_BACKEND_URL='): BACKEND_URL = line.strip().split('=')[1].strip('"\'') break API_URL = f"{BACKEND_URL}/api" print(f"Testing CMS Article Loading API at: {API_URL}") class CMSArticleLoadingTest(unittest.TestCase): """Test suite specifically for CMS Article Loading Issue - /api/cms/articles endpoint""" def setUp(self): """Set up test fixtures before each test method""" # Seed the database to ensure we have data to test with response = requests.post(f"{API_URL}/seed-database") self.assertEqual(response.status_code, 200, "Failed to seed database") print("Database seeded successfully") def test_01_cms_articles_basic_endpoint(self): """Test basic CMS articles endpoint functionality""" print("\n--- Testing Basic CMS Articles Endpoint ---") # Test 1: Basic GET /api/cms/articles request print("\n1. Testing GET /api/cms/articles (basic request)") response = requests.get(f"{API_URL}/cms/articles") print(f"Response Status: {response.status_code}") print(f"Response Headers: {dict(response.headers)}") if response.status_code != 200: print(f"❌ CRITICAL ERROR: Basic CMS articles request failed") print(f"Response Text: {response.text}") self.fail(f"Basic CMS articles request failed with status {response.status_code}") articles = response.json() self.assertIsInstance(articles, list, "CMS articles response should be a list") print(f"✅ Basic CMS articles endpoint working - returned {len(articles)} articles") # Verify article structure if articles exist if articles: article = articles[0] required_fields = ["id", "title", "summary", "image_url", "author", "language", "category", "is_published", "published_at"] missing_fields = [] for field in required_fields: if field not in article: missing_fields.append(field) if missing_fields: print(f"⚠️ Missing fields in article structure: {missing_fields}") else: print("✅ Article structure verified - all required fields present") print(f"Sample article: {article['title']} (ID: {article['id']})") def test_02_cms_articles_with_frontend_parameters(self): """Test CMS articles endpoint with exact parameters used by frontend""" print("\n--- Testing CMS Articles with Frontend Parameters ---") # Test 2: GET /api/cms/articles?language=en&limit=1000 (exact frontend call) print("\n2. Testing GET /api/cms/articles?language=en&limit=1000 (frontend parameters)") response = requests.get(f"{API_URL}/cms/articles?language=en&limit=1000") print(f"Response Status: {response.status_code}") if response.status_code != 200: print(f"❌ CRITICAL ERROR: Frontend parameter request failed") print(f"Response Text: {response.text}") self.fail(f"Frontend parameter request failed with status {response.status_code}") articles = response.json() self.assertIsInstance(articles, list, "CMS articles response should be a list") print(f"✅ Frontend parameter request working - returned {len(articles)} articles") # Verify language filtering english_articles = [a for a in articles if a.get('language') == 'en'] print(f" English articles: {len(english_articles)}") print(f" Total articles: {len(articles)}") # Test 3: Different language parameters print("\n3. Testing different language parameters") for lang in ['en', 'te', 'hi']: response = requests.get(f"{API_URL}/cms/articles?language={lang}&limit=100") self.assertEqual(response.status_code, 200, f"Failed to get articles for language {lang}") lang_articles = response.json() print(f" Language '{lang}': {len(lang_articles)} articles") def test_03_cms_articles_parameter_variations(self): """Test CMS articles endpoint with various parameter combinations""" print("\n--- Testing CMS Articles Parameter Variations ---") # Test 4: Different limit values print("\n4. Testing different limit values") test_limits = [10, 20, 50, 100, 500, 1000] for limit in test_limits: response = requests.get(f"{API_URL}/cms/articles?language=en&limit={limit}") self.assertEqual(response.status_code, 200, f"Failed with limit={limit}") articles = response.json() actual_count = len(articles) print(f" Limit {limit}: returned {actual_count} articles") # Verify limit is respected (should not exceed limit) self.assertLessEqual(actual_count, limit, f"Returned more articles than limit={limit}") # Test 5: Skip parameter print("\n5. Testing skip parameter") response = requests.get(f"{API_URL}/cms/articles?language=en&skip=5&limit=10") self.assertEqual(response.status_code, 200, "Failed with skip parameter") skipped_articles = response.json() print(f" Skip=5, Limit=10: returned {len(skipped_articles)} articles") # Test 6: Category filtering print("\n6. Testing category filtering") # First get available categories response = requests.get(f"{API_URL}/cms/articles?language=en&limit=100") all_articles = response.json() if all_articles: categories = list(set(a.get('category') for a in all_articles if a.get('category'))) print(f" Available categories: {categories[:5]}...") # Show first 5 if categories: test_category = categories[0] response = requests.get(f"{API_URL}/cms/articles?language=en&category={test_category}&limit=50") self.assertEqual(response.status_code, 200, f"Failed with category filter: {test_category}") category_articles = response.json() print(f" Category '{test_category}': {len(category_articles)} articles") # Test 7: State filtering print("\n7. Testing state filtering") response = requests.get(f"{API_URL}/cms/articles?language=en&state=ap&limit=50") self.assertEqual(response.status_code, 200, "Failed with state filter") state_articles = response.json() print(f" State 'ap': {len(state_articles)} articles") def test_04_cms_articles_response_format(self): """Test CMS articles response format and data quality""" print("\n--- Testing CMS Articles Response Format ---") # Test 8: Response format validation print("\n8. Testing response format validation") response = requests.get(f"{API_URL}/cms/articles?language=en&limit=20") self.assertEqual(response.status_code, 200, "Failed to get articles for format validation") articles = response.json() if not articles: print("⚠️ No articles found for format validation") return print(f"Validating format of {len(articles)} articles...") # Check each article structure valid_articles = 0 issues_found = [] for i, article in enumerate(articles): article_issues = [] # Required fields check required_fields = { 'id': int, 'title': str, 'summary': str, 'author': str, 'language': str, 'category': str, 'is_published': bool } for field, expected_type in required_fields.items(): if field not in article: article_issues.append(f"Missing field: {field}") elif article[field] is not None and not isinstance(article[field], expected_type): article_issues.append(f"Wrong type for {field}: expected {expected_type.__name__}, got {type(article[field]).__name__}") # Optional fields check optional_fields = ['image_url', 'short_title', 'content_type', 'artists', 'published_at', 'scheduled_publish_at', 'view_count'] for field in optional_fields: if field in article and article[field] is not None: # Just verify they exist, type checking is less strict for optional fields pass if not article_issues: valid_articles += 1 else: issues_found.extend([f"Article {i+1} (ID: {article.get('id', 'unknown')}): {issue}" for issue in article_issues]) print(f"✅ Valid articles: {valid_articles}/{len(articles)}") if issues_found: print(f"⚠️ Issues found in {len(articles) - valid_articles} articles:") for issue in issues_found[:10]: # Show first 10 issues print(f" - {issue}") if len(issues_found) > 10: print(f" ... and {len(issues_found) - 10} more issues") # Test 9: Data quality check print("\n9. Testing data quality") quality_issues = [] for article in articles[:10]: # Check first 10 articles if not article.get('title') or len(article['title'].strip()) < 3: quality_issues.append(f"Article {article.get('id')}: Title too short or empty") if not article.get('summary') or len(article['summary'].strip()) < 10: quality_issues.append(f"Article {article.get('id')}: Summary too short or empty") if not article.get('author') or len(article['author'].strip()) < 2: quality_issues.append(f"Article {article.get('id')}: Author name too short or empty") if quality_issues: print(f"⚠️ Data quality issues found:") for issue in quality_issues: print(f" - {issue}") else: print("✅ Data quality check passed") def test_05_cms_articles_error_handling(self): """Test CMS articles error handling and edge cases""" print("\n--- Testing CMS Articles Error Handling ---") # Test 10: Invalid parameters print("\n10. Testing invalid parameters") # Invalid language response = requests.get(f"{API_URL}/cms/articles?language=invalid_lang&limit=10") print(f" Invalid language response: {response.status_code}") # Should either return 200 with empty list or handle gracefully # Negative limit response = requests.get(f"{API_URL}/cms/articles?language=en&limit=-1") print(f" Negative limit response: {response.status_code}") # Zero limit response = requests.get(f"{API_URL}/cms/articles?language=en&limit=0") print(f" Zero limit response: {response.status_code}") # Very large limit response = requests.get(f"{API_URL}/cms/articles?language=en&limit=999999") print(f" Very large limit response: {response.status_code}") # Negative skip response = requests.get(f"{API_URL}/cms/articles?language=en&skip=-1&limit=10") print(f" Negative skip response: {response.status_code}") def test_06_cms_articles_performance(self): """Test CMS articles performance""" print("\n--- Testing CMS Articles Performance ---") # Test 11: Response time for large requests print("\n11. Testing response time for large requests") start_time = time.time() response = requests.get(f"{API_URL}/cms/articles?language=en&limit=1000") end_time = time.time() response_time = end_time - start_time self.assertEqual(response.status_code, 200, "Large request failed") articles = response.json() print(f"✅ Large request performance: {response_time:.3f} seconds for {len(articles)} articles") if response_time > 5.0: print(f"⚠️ Response time is slow: {response_time:.3f} seconds") else: print(f"✅ Response time acceptable: {response_time:.3f} seconds") def test_07_database_verification(self): """Verify articles exist in database""" print("\n--- Testing Database Verification ---") # Test 12: Verify articles exist in database print("\n12. Testing database article existence") # Get articles from CMS endpoint response = requests.get(f"{API_URL}/cms/articles?language=en&limit=100") self.assertEqual(response.status_code, 200, "Failed to get CMS articles") cms_articles = response.json() # Get articles from regular endpoint for comparison response = requests.get(f"{API_URL}/articles?limit=100") self.assertEqual(response.status_code, 200, "Failed to get regular articles") regular_articles = response.json() print(f"CMS articles count: {len(cms_articles)}") print(f"Regular articles count: {len(regular_articles)}") if len(cms_articles) == 0 and len(regular_articles) == 0: print("⚠️ No articles found in database - this might be the root cause") elif len(cms_articles) == 0 and len(regular_articles) > 0: print("❌ CRITICAL: Regular articles exist but CMS articles endpoint returns empty") elif len(cms_articles) > 0: print("✅ Articles exist in database and CMS endpoint returns them") # Test specific article retrieval if cms_articles: test_article_id = cms_articles[0]['id'] response = requests.get(f"{API_URL}/cms/articles/{test_article_id}") if response.status_code == 200: print(f"✅ Individual article retrieval working (ID: {test_article_id})") else: print(f"❌ Individual article retrieval failed (ID: {test_article_id})") def test_08_frontend_compatibility(self): """Test frontend compatibility and exact use case""" print("\n--- Testing Frontend Compatibility ---") # Test 13: Simulate exact frontend Dashboard.jsx fetchArticles() call print("\n13. Testing exact frontend fetchArticles() simulation") # This simulates the exact call made by Dashboard.jsx params = { 'language': 'en', 'limit': 1000 } print(f"Making request with params: {params}") response = requests.get(f"{API_URL}/cms/articles", params=params) print(f"Response status: {response.status_code}") print(f"Response headers: {dict(response.headers)}") if response.status_code != 200: print(f"❌ CRITICAL: Frontend simulation failed") print(f"Response text: {response.text}") return try: articles = response.json() print(f"✅ Frontend simulation successful - received {len(articles)} articles") # Check if response is what frontend expects if isinstance(articles, list): print("✅ Response is array as expected by frontend") if articles: # Check first article structure matches frontend expectations first_article = articles[0] frontend_expected_fields = ['id', 'title', 'summary', 'image_url', 'author', 'category', 'published_at'] missing_frontend_fields = [] for field in frontend_expected_fields: if field not in first_article: missing_frontend_fields.append(field) if missing_frontend_fields: print(f"⚠️ Missing fields expected by frontend: {missing_frontend_fields}") else: print("✅ All frontend-expected fields present") # Show sample article data print(f"Sample article for frontend:") print(f" ID: {first_article.get('id')}") print(f" Title: {first_article.get('title', 'N/A')}") print(f" Author: {first_article.get('author', 'N/A')}") print(f" Category: {first_article.get('category', 'N/A')}") print(f" Published: {first_article.get('is_published', 'N/A')}") else: print("❌ CRITICAL: Empty articles array - this is likely the root cause of 'Loading articles...' issue") else: print(f"❌ CRITICAL: Response is not an array, got {type(articles)}") except json.JSONDecodeError as e: print(f"❌ CRITICAL: Invalid JSON response - {e}") print(f"Response text: {response.text[:500]}...") if __name__ == "__main__": # Create a test suite focusing on CMS Article Loading suite = unittest.TestSuite() # Add tests in priority order suite.addTest(CMSArticleLoadingTest("test_01_cms_articles_basic_endpoint")) suite.addTest(CMSArticleLoadingTest("test_02_cms_articles_with_frontend_parameters")) suite.addTest(CMSArticleLoadingTest("test_03_cms_articles_parameter_variations")) suite.addTest(CMSArticleLoadingTest("test_04_cms_articles_response_format")) suite.addTest(CMSArticleLoadingTest("test_05_cms_articles_error_handling")) suite.addTest(CMSArticleLoadingTest("test_06_cms_articles_performance")) suite.addTest(CMSArticleLoadingTest("test_07_database_verification")) suite.addTest(CMSArticleLoadingTest("test_08_frontend_compatibility")) # Run the tests runner = unittest.TextTestRunner(verbosity=2) result = runner.run(suite) # Print summary print(f"\n{'='*80}") print("CMS ARTICLE LOADING BACKEND TESTING SUMMARY") print(f"{'='*80}") print(f"Tests run: {result.testsRun}") print(f"Failures: {len(result.failures)}") print(f"Errors: {len(result.errors)}") if result.failures: print("\nFAILURES:") for test, traceback in result.failures: print(f"- {test}: {traceback}") if result.errors: print("\nERRORS:") for test, traceback in result.errors: print(f"- {test}: {traceback}") if result.wasSuccessful(): print("\n🎉 ALL CMS ARTICLE LOADING TESTS PASSED!") print("✅ Basic CMS articles endpoint working") print("✅ Frontend parameter compatibility working") print("✅ Parameter variations working") print("✅ Response format correct") print("✅ Error handling working") print("✅ Performance acceptable") print("✅ Database verification successful") print("✅ Frontend compatibility confirmed") print("\n🔍 ROOT CAUSE ANALYSIS: If Dashboard is still stuck on 'Loading articles...', the issue is likely in frontend JavaScript code, not backend API.") else: print(f"\n❌ {len(result.failures + result.errors)} TESTS FAILED") print("\n🔍 ROOT CAUSE ANALYSIS: Backend API issues identified that could cause 'Loading articles...' problem.")

#!/usr/bin/env python3 import requests import json import unittest import os import sys from datetime import datetime import time # Get the backend URL from the frontend .env file with open('/app/frontend/.env', 'r') as f: for line in f: if line.startswith('REACT_APP_BACKEND_URL='): BACKEND_URL = line.strip().split('=')[1].strip('"\'') break API_URL = f"{BACKEND_URL}/api" print(f"Testing CMS Dashboard API at: {API_URL}") class CMSDashboardBackendTest(unittest.TestCase): """Test suite for CMS Dashboard functionality - Image Galleries and Topics with pagination""" def setUp(self): """Set up test fixtures before each test method""" # Seed the database to ensure we have data to test with response = requests.post(f"{API_URL}/seed-database") self.assertEqual(response.status_code, 200, "Failed to seed database") print("Database seeded successfully") def test_01_gallery_management_apis(self): """Test Gallery Management APIs for CMS Dashboard""" print("\n--- Testing Gallery Management APIs ---") # Test 1: GET /api/galleries - should return galleries data for pagination print("\n1. Testing GET /api/galleries endpoint") response = requests.get(f"{API_URL}/galleries") self.assertEqual(response.status_code, 200, "Failed to get galleries") galleries = response.json() self.assertIsInstance(galleries, list, "Galleries response should be a list") print(f"✅ GET /api/galleries working - returned {len(galleries)} galleries") # Test pagination parameters response = requests.get(f"{API_URL}/galleries?skip=0&limit=10") self.assertEqual(response.status_code, 200, "Failed to get galleries with pagination") paginated_galleries = response.json() self.assertLessEqual(len(paginated_galleries), 10, "Pagination limit not working") print(f"✅ Gallery pagination working - returned {len(paginated_galleries)} galleries with limit=10") # Test large result set support (up to 1000 items) response = requests.get(f"{API_URL}/galleries?limit=1000") self.assertEqual(response.status_code, 200, "Failed to get galleries with large limit") large_galleries = response.json() print(f"✅ Large result set support working - can handle limit=1000, returned {len(large_galleries)} galleries") # Test 2: POST /api/galleries - Create gallery print("\n2. Testing POST /api/galleries endpoint") new_gallery = { "gallery_id": f"test-gallery-{int(time.time())}", "title": "Test Gallery for CMS Dashboard", "artists": ["Test Artist 1", "Test Artist 2"], "images": [ {"id": "img1", "name": "test1.jpg", "data": "base64data1", "size": 1024}, {"id": "img2", "name": "test2.jpg", "data": "base64data2", "size": 2048} ], "gallery_type": "vertical" } response = requests.post(f"{API_URL}/galleries", json=new_gallery) self.assertEqual(response.status_code, 200, f"Failed to create gallery: {response.text}") created_gallery = response.json() # Verify gallery structure required_fields = ["id", "gallery_id", "title", "artists", "images", "gallery_type", "created_at", "updated_at"] for field in required_fields: self.assertIn(field, created_gallery, f"Gallery missing required field: {field}") self.assertEqual(created_gallery["title"], new_gallery["title"]) self.assertEqual(created_gallery["artists"], new_gallery["artists"]) self.assertEqual(created_gallery["gallery_type"], new_gallery["gallery_type"]) gallery_id = created_gallery["gallery_id"] print(f"✅ Gallery creation working - created gallery with ID: {gallery_id}") # Test 3: GET /api/galleries/{id} - Get specific gallery print("\n3. Testing GET /api/galleries/{id} endpoint") response = requests.get(f"{API_URL}/galleries/{gallery_id}") self.assertEqual(response.status_code, 200, f"Failed to get gallery {gallery_id}") gallery = response.json() self.assertEqual(gallery["gallery_id"], gallery_id) self.assertEqual(gallery["title"], new_gallery["title"]) print(f"✅ Gallery retrieval working - retrieved gallery: {gallery['title']}") # Test 4: PUT /api/galleries/{id} - Update gallery print("\n4. Testing PUT /api/galleries/{id} endpoint") update_data = { "title": "Updated Test Gallery", "artists": ["Updated Artist 1", "Updated Artist 2", "New Artist 3"] } response = requests.put(f"{API_URL}/galleries/{gallery_id}", json=update_data) self.assertEqual(response.status_code, 200, f"Failed to update gallery {gallery_id}") updated_gallery = response.json() self.assertEqual(updated_gallery["title"], update_data["title"]) self.assertEqual(updated_gallery["artists"], update_data["artists"]) print(f"✅ Gallery update working - updated title to: {updated_gallery['title']}") # Test 5: GET /api/galleries/{id}/topics - Gallery topics management print("\n5. Testing GET /api/galleries/{id}/topics endpoint") response = requests.get(f"{API_URL}/galleries/{created_gallery['id']}/topics") self.assertEqual(response.status_code, 200, f"Failed to get topics for gallery {created_gallery['id']}") gallery_topics = response.json() self.assertIsInstance(gallery_topics, list, "Gallery topics should be a list") print(f"✅ Gallery topics retrieval working - found {len(gallery_topics)} topics for gallery") # Test 6: DELETE /api/galleries/{id} - Delete gallery print("\n6. Testing DELETE /api/galleries/{id} endpoint") response = requests.delete(f"{API_URL}/galleries/{gallery_id}") self.assertEqual(response.status_code, 200, f"Failed to delete gallery {gallery_id}") delete_response = response.json() self.assertIn("message", delete_response) print(f"✅ Gallery deletion working - {delete_response['message']}") # Verify gallery is deleted response = requests.get(f"{API_URL}/galleries/{gallery_id}") self.assertEqual(response.status_code, 404, "Deleted gallery should return 404") print("✅ Gallery deletion verified - returns 404 for deleted gallery") def test_02_topics_management_apis(self): """Test Topics Management APIs for CMS Dashboard""" print("\n--- Testing Topics Management APIs ---") # Test 1: GET /api/topics with limit=1000 parameter print("\n1. Testing GET /api/topics with limit=1000") response = requests.get(f"{API_URL}/topics?limit=1000") self.assertEqual(response.status_code, 200, "Failed to get topics with large limit") all_topics = response.json() self.assertIsInstance(all_topics, list, "Topics response should be a list") print(f"✅ Topics large limit working - returned {len(all_topics)} topics with limit=1000") # Verify topic structure if all_topics: topic = all_topics[0] required_fields = ["id", "title", "slug", "category", "language", "created_at", "updated_at", "articles_count"] for field in required_fields: self.assertIn(field, topic, f"Topic missing required field: {field}") print("✅ Topic structure verified - all required fields present") # Test 2: GET /api/topics with filtering by language and category print("\n2. Testing GET /api/topics with filtering") # Test language filtering response = requests.get(f"{API_URL}/topics?language=en&limit=50") self.assertEqual(response.status_code, 200, "Failed to get topics with language filter") en_topics = response.json() print(f"✅ Language filtering working - found {len(en_topics)} English topics") # Test category filtering (get available categories first) if all_topics: # Get unique categories from topics categories = list(set(topic["category"] for topic in all_topics if topic["category"])) if categories: test_category = categories[0] response = requests.get(f"{API_URL}/topics?category={test_category}&limit=50") self.assertEqual(response.status_code, 200, f"Failed to get topics with category filter: {test_category}") category_topics = response.json() print(f"✅ Category filtering working - found {len(category_topics)} topics in category '{test_category}'") # Test search functionality response = requests.get(f"{API_URL}/topics?search=test&limit=50") self.assertEqual(response.status_code, 200, "Failed to get topics with search filter") search_topics = response.json() print(f"✅ Search functionality working - found {len(search_topics)} topics matching 'test'") # Test 3: POST /api/topics - Create topic print("\n3. Testing POST /api/topics endpoint") new_topic = { "title": f"Test Topic for CMS Dashboard {int(time.time())}", "description": "This is a test topic for CMS Dashboard testing", "category": "Technology", "language": "en" } response = requests.post(f"{API_URL}/topics", json=new_topic) self.assertEqual(response.status_code, 200, f"Failed to create topic: {response.text}") created_topic = response.json() # Verify topic creation self.assertEqual(created_topic["title"], new_topic["title"]) self.assertEqual(created_topic["category"], new_topic["category"]) self.assertEqual(created_topic["language"], new_topic["language"]) self.assertIn("slug", created_topic) self.assertEqual(created_topic["articles_count"], 0) topic_id = created_topic["id"] print(f"✅ Topic creation working - created topic with ID: {topic_id}") # Test 4: GET /api/topics/{id} - Get specific topic print("\n4. Testing GET /api/topics/{id} endpoint") response = requests.get(f"{API_URL}/topics/{topic_id}") self.assertEqual(response.status_code, 200, f"Failed to get topic {topic_id}") topic = response.json() self.assertEqual(topic["id"], topic_id) self.assertEqual(topic["title"], new_topic["title"]) print(f"✅ Topic retrieval working - retrieved topic: {topic['title']}") # Test 5: PUT /api/topics/{id} - Update topic print("\n5. Testing PUT /api/topics/{id} endpoint") update_data = { "title": "Updated Test Topic for CMS Dashboard", "description": "Updated description for testing", "category": "Updated Technology" } response = requests.put(f"{API_URL}/topics/{topic_id}", json=update_data) self.assertEqual(response.status_code, 200, f"Failed to update topic {topic_id}") updated_topic = response.json() self.assertEqual(updated_topic["title"], update_data["title"]) self.assertEqual(updated_topic["category"], update_data["category"]) print(f"✅ Topic update working - updated title to: {updated_topic['title']}") # Test 6: GET /api/topics/{id}/articles - Topic articles management print("\n6. Testing GET /api/topics/{id}/articles endpoint") response = requests.get(f"{API_URL}/topics/{topic_id}/articles") self.assertEqual(response.status_code, 200, f"Failed to get articles for topic {topic_id}") topic_articles = response.json() self.assertIsInstance(topic_articles, list, "Topic articles should be a list") print(f"✅ Topic articles retrieval working - found {len(topic_articles)} articles for topic") # Test 7: GET /api/topics/{id}/galleries - Topic galleries management print("\n7. Testing GET /api/topics/{id}/galleries endpoint") response = requests.get(f"{API_URL}/topics/{topic_id}/galleries") self.assertEqual(response.status_code, 200, f"Failed to get galleries for topic {topic_id}") topic_galleries = response.json() self.assertIsInstance(topic_galleries, list, "Topic galleries should be a list") print(f"✅ Topic galleries retrieval working - found {len(topic_galleries)} galleries for topic") # Test 8: DELETE /api/topics/{id} - Delete topic print("\n8. Testing DELETE /api/topics/{id} endpoint") response = requests.delete(f"{API_URL}/topics/{topic_id}") self.assertEqual(response.status_code, 200, f"Failed to delete topic {topic_id}") delete_response = response.json() self.assertIn("message", delete_response) print(f"✅ Topic deletion working - {delete_response['message']}") # Verify topic is deleted response = requests.get(f"{API_URL}/topics/{topic_id}") self.assertEqual(response.status_code, 404, "Deleted topic should return 404") print("✅ Topic deletion verified - returns 404 for deleted topic") def test_03_artist_management_apis(self): """Test Artist Management APIs for gallery filtering""" print("\n--- Testing Artist Management APIs ---") # Test 1: Get galleries to check artist data print("\n1. Testing Artist data in galleries") response = requests.get(f"{API_URL}/galleries") self.assertEqual(response.status_code, 200, "Failed to get galleries") galleries = response.json() # Check if galleries have artist information artists_found = [] for gallery in galleries: if "artists" in gallery and gallery["artists"]: artists_found.extend(gallery["artists"]) unique_artists = list(set(artists_found)) print(f"✅ Artist data available - found {len(unique_artists)} unique artists across galleries") if unique_artists: print(f" Sample artists: {unique_artists[:5]}") # Test 2: Create gallery with artist data for filtering print("\n2. Testing Gallery creation with artist data") test_artists = ["Samantha Ruth Prabhu", "Rakul Preet Singh", "Pooja Hegde"] new_gallery = { "gallery_id": f"artist-test-gallery-{int(time.time())}", "title": "Artist Test Gallery", "artists": test_artists, "images": [ {"id": "img1", "name": "artist1.jpg", "data": "base64data1", "size": 1024} ], "gallery_type": "vertical" } response = requests.post(f"{API_URL}/galleries", json=new_gallery) self.assertEqual(response.status_code, 200, "Failed to create gallery with artists") created_gallery = response.json() self.assertEqual(created_gallery["artists"], test_artists) print(f"✅ Gallery with artists created - artists: {created_gallery['artists']}") # Test 3: Verify artist filtering capability print("\n3. Testing Artist filtering capability") # Get all galleries and check artist filtering potential response = requests.get(f"{API_URL}/galleries") all_galleries = response.json() # Group galleries by artist for filtering simulation artist_gallery_map = {} for gallery in all_galleries: if "artists" in gallery and gallery["artists"]: for artist in gallery["artists"]: if artist not in artist_gallery_map: artist_gallery_map[artist] = [] artist_gallery_map[artist].append(gallery) print(f"✅ Artist filtering data available - {len(artist_gallery_map)} artists can be used for filtering") # Clean up test gallery response = requests.delete(f"{API_URL}/galleries/{created_gallery['gallery_id']}") self.assertEqual(response.status_code, 200, "Failed to delete test gallery") print("✅ Test gallery cleanup completed") def test_04_pagination_support(self): """Test Pagination Support for large result sets""" print("\n--- Testing Pagination Support ---") # Test 1: Gallery pagination with various limits print("\n1. Testing Gallery pagination") test_limits = [10, 15, 20, 50, 100, 1000] for limit in test_limits: response = requests.get(f"{API_URL}/galleries?limit={limit}") self.assertEqual(response.status_code, 200, f"Failed to get galleries with limit={limit}") galleries = response.json() self.assertLessEqual(len(galleries), limit, f"Returned more galleries than limit={limit}") print(f"✅ Gallery pagination working with limit={limit} - returned {len(galleries)} galleries") # Test skip parameter response = requests.get(f"{API_URL}/galleries?skip=5&limit=10") self.assertEqual(response.status_code, 200, "Failed to get galleries with skip parameter") skipped_galleries = response.json() print(f"✅ Gallery skip parameter working - returned {len(skipped_galleries)} galleries with skip=5") # Test 2: Topics pagination with various limits print("\n2. Testing Topics pagination") for limit in test_limits: response = requests.get(f"{API_URL}/topics?limit={limit}") self.assertEqual(response.status_code, 200, f"Failed to get topics with limit={limit}") topics = response.json() self.assertLessEqual(len(topics), limit, f"Returned more topics than limit={limit}") print(f"✅ Topics pagination working with limit={limit} - returned {len(topics)} topics") # Test skip parameter for topics response = requests.get(f"{API_URL}/topics?skip=3&limit=15") self.assertEqual(response.status_code, 200, "Failed to get topics with skip parameter") skipped_topics = response.json() print(f"✅ Topics skip parameter working - returned {len(skipped_topics)} topics with skip=3") # Test 3: Combined filtering and pagination print("\n3. Testing Combined filtering and pagination") # Topics with language filter and pagination response = requests.get(f"{API_URL}/topics?language=en&skip=0&limit=20") self.assertEqual(response.status_code, 200, "Failed to get topics with language filter and pagination") filtered_topics = response.json() print(f"✅ Combined filtering and pagination working - returned {len(filtered_topics)} English topics with limit=20") # Test 4: Error handling for invalid pagination parameters print("\n4. Testing Error handling for pagination") # Test negative skip response = requests.get(f"{API_URL}/galleries?skip=-1&limit=10") # Should handle gracefully (either error or treat as 0) print(f" Negative skip parameter response: {response.status_code}") # Test zero limit response = requests.get(f"{API_URL}/galleries?skip=0&limit=0") # Should handle gracefully print(f" Zero limit parameter response: {response.status_code}") # Test very large skip response = requests.get(f"{API_URL}/galleries?skip=10000&limit=10") self.assertEqual(response.status_code, 200, "Should handle large skip values") large_skip_galleries = response.json() print(f"✅ Large skip parameter handled - returned {len(large_skip_galleries)} galleries") def test_05_error_handling_and_edge_cases(self): """Test Error handling and edge cases""" print("\n--- Testing Error Handling and Edge Cases ---") # Test 1: Non-existent gallery print("\n1. Testing Non-existent gallery handling") response = requests.get(f"{API_URL}/galleries/non-existent-gallery-id") self.assertEqual(response.status_code, 404, "Non-existent gallery should return 404") print("✅ Non-existent gallery returns 404") # Test 2: Non-existent topic print("\n2. Testing Non-existent topic handling") response = requests.get(f"{API_URL}/topics/99999") self.assertEqual(response.status_code, 404, "Non-existent topic should return 404") print("✅ Non-existent topic returns 404") # Test 3: Invalid gallery creation data print("\n3. Testing Invalid gallery creation") invalid_gallery = { "gallery_id": "", # Empty gallery_id "title": "", # Empty title "artists": [], "images": [], "gallery_type": "invalid_type" } response = requests.post(f"{API_URL}/galleries", json=invalid_gallery) # Should handle validation errors appropriately print(f" Invalid gallery creation response: {response.status_code}") # Test 4: Invalid topic creation data print("\n4. Testing Invalid topic creation") invalid_topic = { "title": "", # Empty title "category": "", # Empty category "language": "invalid_lang" } response = requests.post(f"{API_URL}/topics", json=invalid_topic) # Should handle validation errors appropriately print(f" Invalid topic creation response: {response.status_code}") # Test 5: Duplicate gallery ID print("\n5. Testing Duplicate gallery ID handling") # First create a gallery test_gallery = { "gallery_id": f"duplicate-test-{int(time.time())}", "title": "Duplicate Test Gallery", "artists": ["Test Artist"], "images": [{"id": "img1", "name": "test.jpg", "data": "data", "size": 1024}], "gallery_type": "vertical" } response = requests.post(f"{API_URL}/galleries", json=test_gallery) self.assertEqual(response.status_code, 200, "Failed to create first gallery") # Try to create another with same gallery_id response = requests.post(f"{API_URL}/galleries", json=test_gallery) self.assertEqual(response.status_code, 400, "Duplicate gallery_id should return 400") print("✅ Duplicate gallery_id properly rejected with 400") # Clean up response = requests.delete(f"{API_URL}/galleries/{test_gallery['gallery_id']}") self.assertEqual(response.status_code, 200, "Failed to delete test gallery") def test_06_performance_and_load_testing(self): """Test Performance and load handling""" print("\n--- Testing Performance and Load Handling ---") # Test 1: Response time for gallery listing print("\n1. Testing Gallery listing performance") start_time = time.time() response = requests.get(f"{API_URL}/galleries?limit=100") end_time = time.time() response_time = end_time - start_time self.assertEqual(response.status_code, 200, "Gallery listing failed") self.assertLess(response_time, 3.0, "Gallery listing too slow") print(f"✅ Gallery listing performance acceptable: {response_time:.3f} seconds for 100 galleries") # Test 2: Response time for topics listing with large limit print("\n2. Testing Topics listing performance") start_time = time.time() response = requests.get(f"{API_URL}/topics?limit=1000") end_time = time.time() response_time = end_time - start_time self.assertEqual(response.status_code, 200, "Topics listing failed") self.assertLess(response_time, 5.0, "Topics listing too slow") print(f"✅ Topics listing performance acceptable: {response_time:.3f} seconds for 1000 topics") # Test 3: Concurrent requests handling print("\n3. Testing Concurrent requests handling") import threading import queue results = queue.Queue() def make_request(): try: response = requests.get(f"{API_URL}/galleries?limit=50") results.put(response.status_code) except Exception as e: results.put(f"Error: {e}") # Create 5 concurrent threads threads = [] for i in range(5): thread = threading.Thread(target=make_request) threads.append(thread) thread.start() # Wait for all threads to complete for thread in threads: thread.join() # Check results success_count = 0 while not results.empty(): result = results.get() if result == 200: success_count += 1 self.assertEqual(success_count, 5, "Not all concurrent requests succeeded") print(f"✅ Concurrent requests handling working - {success_count}/5 requests successful") if __name__ == "__main__": # Create a test suite focusing on CMS Dashboard functionality suite = unittest.TestSuite() # Add tests in priority order suite.addTest(CMSDashboardBackendTest("test_01_gallery_management_apis")) suite.addTest(CMSDashboardBackendTest("test_02_topics_management_apis")) suite.addTest(CMSDashboardBackendTest("test_03_artist_management_apis")) suite.addTest(CMSDashboardBackendTest("test_04_pagination_support")) suite.addTest(CMSDashboardBackendTest("test_05_error_handling_and_edge_cases")) suite.addTest(CMSDashboardBackendTest("test_06_performance_and_load_testing")) # Run the tests runner = unittest.TextTestRunner(verbosity=2) result = runner.run(suite) # Print summary print(f"\n{'='*80}") print("CMS DASHBOARD BACKEND TESTING SUMMARY") print(f"{'='*80}") print(f"Tests run: {result.testsRun}") print(f"Failures: {len(result.failures)}") print(f"Errors: {len(result.errors)}") if result.failures: print("\nFAILURES:") for test, traceback in result.failures: print(f"- {test}: {traceback}") if result.errors: print("\nERRORS:") for test, traceback in result.errors: print(f"- {test}: {traceback}") if result.wasSuccessful(): print("\n🎉 ALL CMS DASHBOARD BACKEND TESTS PASSED!") print("✅ Gallery Management APIs working correctly") print("✅ Topics Management APIs working correctly") print("✅ Artist Management APIs working correctly") print("✅ Pagination Support working correctly") print("✅ Error Handling working correctly") print("✅ Performance and Load Handling acceptable") else: print(f"\n❌ {len(result.failures + result.errors)} TESTS FAILED")

#!/usr/bin/env python3 import requests import json import unittest import os import sys from datetime import datetime # Get the backend URL from the frontend .env file with open('/app/frontend/.env', 'r') as f: for line in f: if line.startswith('REACT_APP_BACKEND_URL='): BACKEND_URL = line.strip().split('=')[1].strip('"\'') break API_URL = f"{BACKEND_URL}/api" print(f"Testing API at: {API_URL}") class ComprehensiveAPITest(unittest.TestCase): """Comprehensive test suite for Blog CMS API after frontend-backend communication fix""" def setUp(self): """Set up test fixtures before each test method""" # Seed the database to ensure we have data to test with response = requests.post(f"{API_URL}/seed-database") self.assertEqual(response.status_code, 200, "Failed to seed database") print("Database seeded successfully") def test_01_health_check_and_json_response(self): """Test that API returns proper JSON instead of HTML""" print("\n=== TESTING API HEALTH AND JSON RESPONSE ===") response = requests.get(f"{API_URL}/") self.assertEqual(response.status_code, 200, "Health check failed") # Verify it's JSON, not HTML content_type = response.headers.get('content-type', '') self.assertIn('application/json', content_type, "API should return JSON, not HTML") data = response.json() self.assertEqual(data["message"], "Blog CMS API is running") self.assertEqual(data["status"], "healthy") print("✅ API returns proper JSON response (not HTML)") def test_02_politics_api_endpoint(self): """Test the Politics API endpoint specifically: /api/articles/sections/politics""" print("\n=== TESTING POLITICS API ENDPOINT ===") response = requests.get(f"{API_URL}/articles/sections/politics") self.assertEqual(response.status_code, 200, "Politics API endpoint failed") # Verify it's JSON content_type = response.headers.get('content-type', '') self.assertIn('application/json', content_type, "Politics API should return JSON") data = response.json() self.assertIsInstance(data, dict, "Politics response should be a dictionary") # Check structure self.assertIn("state_politics", data, "Response missing 'state_politics' array") self.assertIn("national_politics", data, "Response missing 'national_politics' array") state_articles = data["state_politics"] national_articles = data["national_politics"] self.assertIsInstance(state_articles, list, "'state_politics' should be a list") self.assertIsInstance(national_articles, list, "'national_politics' should be a list") print(f"✅ Politics API endpoint working - State: {len(state_articles)}, National: {len(national_articles)} articles") # Check for Article ID 74 "Jagan - USA Tour" with state "ap" article_74_found = False for article in state_articles: if article.get("id") == 74 and "Jagan" in article.get("title", "") and "USA Tour" in article.get("title", ""): article_74_found = True # Check if states field exists and contains "ap" states = article.get("states") if states: if isinstance(states, str): # Parse JSON string if needed import json try: states_list = json.loads(states) self.assertIn("ap", states_list, "Article 74 should have 'ap' in states") except: self.assertIn("ap", states, "Article 74 should contain 'ap' in states") elif isinstance(states, list): self.assertIn("ap", states, "Article 74 should have 'ap' in states list") print(f"✅ Article ID 74 'Jagan - USA Tour' found with state 'ap': {article.get('title')}") break if not article_74_found: # Check all articles for debugging print("Available articles in state_politics:") for article in state_articles: print(f" - ID {article.get('id')}: {article.get('title')} (states: {article.get('states')})") self.assertTrue(article_74_found, "Article ID 74 'Jagan - USA Tour' with state 'ap' not found in politics API response") def test_03_movies_api_endpoints(self): """Test Movies API endpoints for proper state-based filtering""" print("\n=== TESTING MOVIES API ENDPOINTS ===") # Test main movies section endpoint response = requests.get(f"{API_URL}/articles/sections/movies") self.assertEqual(response.status_code, 200, "Movies API endpoint failed") content_type = response.headers.get('content-type', '') self.assertIn('application/json', content_type, "Movies API should return JSON") data = response.json() self.assertIsInstance(data, dict, "Movies response should be a dictionary") # Check structure self.assertIn("movies", data, "Response missing 'movies' array") self.assertIn("bollywood", data, "Response missing 'bollywood' array") movies_articles = data["movies"] bollywood_articles = data["bollywood"] print(f"✅ Movies API endpoint working - Movies: {len(movies_articles)}, Bollywood: {len(bollywood_articles)} articles") # Test movie reviews endpoint response = requests.get(f"{API_URL}/articles/sections/movie-reviews") self.assertEqual(response.status_code, 200, "Movie reviews API endpoint failed") reviews_data = response.json() self.assertIn("movie_reviews", reviews_data, "Response missing 'movie_reviews' array") self.assertIn("bollywood", reviews_data, "Response missing 'bollywood' array") print(f"✅ Movie Reviews API endpoint working - Reviews: {len(reviews_data['movie_reviews'])}, Bollywood: {len(reviews_data['bollywood'])} articles") def test_04_top_stories_api_endpoint(self): """Test Top Stories API endpoint""" print("\n=== TESTING TOP STORIES API ENDPOINT ===") response = requests.get(f"{API_URL}/articles/sections/top-stories") self.assertEqual(response.status_code, 200, "Top Stories API endpoint failed") content_type = response.headers.get('content-type', '') self.assertIn('application/json', content_type, "Top Stories API should return JSON") data = response.json() self.assertIsInstance(data, dict, "Top Stories response should be a dictionary") # Check structure self.assertIn("top_stories", data, "Response missing 'top_stories' array") self.assertIn("national", data, "Response missing 'national' array") top_stories = data["top_stories"] national_stories = data["national"] print(f"✅ Top Stories API endpoint working - Top Stories: {len(top_stories)}, National: {len(national_stories)} articles") def test_05_core_section_endpoints(self): """Test other core section endpoints""" print("\n=== TESTING CORE SECTION ENDPOINTS ===") endpoints_to_test = [ "latest-news", "sports", "ai-stock", "fashion-beauty", "hot-topics-gossip", "viral-videos", "box-office", "trending-videos", "ott-movie-reviews", "events-interviews", "new-video-songs", "trailers-teasers", "tv-shows" ] successful_endpoints = 0 for endpoint in endpoints_to_test: try: response = requests.get(f"{API_URL}/articles/sections/{endpoint}") if response.status_code == 200: content_type = response.headers.get('content-type', '') if 'application/json' in content_type: data = response.json() successful_endpoints += 1 print(f"✅ {endpoint} endpoint working - returns JSON") else: print(f"❌ {endpoint} endpoint returns non-JSON content") else: print(f"❌ {endpoint} endpoint failed with status {response.status_code}") except Exception as e: print(f"❌ {endpoint} endpoint error: {str(e)}") print(f"✅ {successful_endpoints}/{len(endpoints_to_test)} section endpoints working properly") self.assertGreater(successful_endpoints, len(endpoints_to_test) * 0.8, "Most section endpoints should be working") def test_06_environment_variables_verification(self): """Verify environment variables are working correctly""" print("\n=== TESTING ENVIRONMENT VARIABLES ===") # Test that we can connect to the API using the environment URL self.assertTrue(BACKEND_URL.startswith('http'), "REACT_APP_BACKEND_URL should be a valid URL") print(f"✅ REACT_APP_BACKEND_URL is properly configured: {BACKEND_URL}") # Test database connection by checking if we can get categories response = requests.get(f"{API_URL}/categories") self.assertEqual(response.status_code, 200, "Database connection via environment variables failed") print("✅ Database connection working via environment variables") def test_07_cms_endpoints_basic_functionality(self): """Test CMS endpoints for basic functionality""" print("\n=== TESTING CMS ENDPOINTS ===") # Test CMS config endpoint response = requests.get(f"{API_URL}/cms/config") self.assertEqual(response.status_code, 200, "CMS config endpoint failed") content_type = response.headers.get('content-type', '') self.assertIn('application/json', content_type, "CMS config should return JSON") config_data = response.json() self.assertIn("languages", config_data, "CMS config missing languages") self.assertIn("states", config_data, "CMS config missing states") self.assertIn("categories", config_data, "CMS config missing categories") print("✅ CMS config endpoint working") # Test CMS articles endpoint response = requests.get(f"{API_URL}/cms/articles") self.assertEqual(response.status_code, 200, "CMS articles endpoint failed") articles_data = response.json() self.assertIsInstance(articles_data, list, "CMS articles should return a list") print(f"✅ CMS articles endpoint working - returned {len(articles_data)} articles") # Test CMS articles with filtering response = requests.get(f"{API_URL}/cms/articles?language=en&limit=5") self.assertEqual(response.status_code, 200, "CMS articles filtering failed") filtered_articles = response.json() self.assertLessEqual(len(filtered_articles), 5, "CMS articles limit parameter not working") print("✅ CMS articles filtering and pagination working") def test_08_article_retrieval_and_json_format(self): """Test individual article retrieval returns proper JSON""" print("\n=== TESTING ARTICLE RETRIEVAL JSON FORMAT ===") # Get list of articles first response = requests.get(f"{API_URL}/articles") self.assertEqual(response.status_code, 200, "Failed to get articles list") articles = response.json() self.assertGreater(len(articles), 0, "No articles found") # Test individual article retrieval article_id = articles[0]["id"] response = requests.get(f"{API_URL}/articles/{article_id}") self.assertEqual(response.status_code, 200, f"Failed to get article {article_id}") content_type = response.headers.get('content-type', '') self.assertIn('application/json', content_type, "Individual article should return JSON") article_data = response.json() self.assertIn("id", article_data) self.assertIn("title", article_data) self.assertIn("content", article_data) print(f"✅ Individual article retrieval returns proper JSON - Article ID {article_id}") def test_09_category_based_article_retrieval(self): """Test category-based article retrieval""" print("\n=== TESTING CATEGORY-BASED ARTICLE RETRIEVAL ===") # Test specific categories mentioned in the review categories_to_test = [ "state-politics", "national-politics", "movie-reviews", "top-stories", "national-top-stories" ] successful_categories = 0 for category in categories_to_test: try: response = requests.get(f"{API_URL}/articles/category/{category}") if response.status_code == 200: content_type = response.headers.get('content-type', '') if 'application/json' in content_type: articles = response.json() successful_categories += 1 print(f"✅ Category '{category}' returns {len(articles)} articles in JSON format") else: print(f"❌ Category '{category}' returns non-JSON content") else: print(f"❌ Category '{category}' failed with status {response.status_code}") except Exception as e: print(f"❌ Category '{category}' error: {str(e)}") print(f"✅ {successful_categories}/{len(categories_to_test)} category endpoints working") self.assertGreater(successful_categories, 0, "At least some category endpoints should work") def test_10_states_field_in_politics_articles(self): """Test that politics articles include states field for filtering""" print("\n=== TESTING STATES FIELD IN POLITICS ARTICLES ===") response = requests.get(f"{API_URL}/articles/sections/politics") self.assertEqual(response.status_code, 200, "Politics API endpoint failed") data = response.json() state_articles = data["state_politics"] states_field_count = 0 ap_articles_count = 0 for article in state_articles: if "states" in article: states_field_count += 1 states = article["states"] # Check if this article is for AP/Telangana if states: if isinstance(states, str): if "ap" in states.lower() or "ts" in states.lower(): ap_articles_count += 1 elif isinstance(states, list): for state in states: if "ap" in str(state).lower() or "ts" in str(state).lower(): ap_articles_count += 1 break print(f"✅ States field present in {states_field_count}/{len(state_articles)} state politics articles") print(f"✅ Found {ap_articles_count} articles for AP/Telangana states") self.assertGreater(states_field_count, 0, "At least some articles should have states field") def test_11_comprehensive_api_status_check(self): """Comprehensive check of all major API endpoints status""" print("\n=== COMPREHENSIVE API STATUS CHECK ===") endpoints_to_check = [ "/", "/categories", "/articles", "/articles/most-read", "/articles/sections/politics", "/articles/sections/movies", "/articles/sections/top-stories", "/articles/sections/movie-reviews", "/cms/config", "/cms/articles" ] working_endpoints = 0 json_endpoints = 0 for endpoint in endpoints_to_check: try: response = requests.get(f"{API_URL}{endpoint}") if response.status_code == 200: working_endpoints += 1 content_type = response.headers.get('content-type', '') if 'application/json' in content_type: json_endpoints += 1 print(f"✅ {endpoint} - Status: 200, Content: JSON") else: print(f"⚠️ {endpoint} - Status: 200, Content: {content_type}") else: print(f"❌ {endpoint} - Status: {response.status_code}") except Exception as e: print(f"❌ {endpoint} - Error: {str(e)}") print(f"\n📊 SUMMARY:") print(f"✅ Working endpoints: {working_endpoints}/{len(endpoints_to_check)}") print(f"✅ JSON endpoints: {json_endpoints}/{len(endpoints_to_check)}") print(f"✅ Success rate: {(working_endpoints/len(endpoints_to_check)*100):.1f}%") # Ensure most endpoints are working self.assertGreater(working_endpoints, len(endpoints_to_check) * 0.8, "Most API endpoints should be working") self.assertGreater(json_endpoints, len(endpoints_to_check) * 0.8, "Most API endpoints should return JSON") if __name__ == "__main__": # Create a test suite with specific order suite = unittest.TestSuite() # Add tests in priority order suite.addTest(ComprehensiveAPITest("test_01_health_check_and_json_response")) suite.addTest(ComprehensiveAPITest("test_02_politics_api_endpoint")) suite.addTest(ComprehensiveAPITest("test_03_movies_api_endpoints")) suite.addTest(ComprehensiveAPITest("test_04_top_stories_api_endpoint")) suite.addTest(ComprehensiveAPITest("test_05_core_section_endpoints")) suite.addTest(ComprehensiveAPITest("test_06_environment_variables_verification")) suite.addTest(ComprehensiveAPITest("test_07_cms_endpoints_basic_functionality")) suite.addTest(ComprehensiveAPITest("test_08_article_retrieval_and_json_format")) suite.addTest(ComprehensiveAPITest("test_09_category_based_article_retrieval")) suite.addTest(ComprehensiveAPITest("test_10_states_field_in_politics_articles")) suite.addTest(ComprehensiveAPITest("test_11_comprehensive_api_status_check")) # Run the tests runner = unittest.TextTestRunner(verbosity=2) result = runner.run(suite) # Print final summary print("\n" + "="*80) print("COMPREHENSIVE API TESTING COMPLETED") print("="*80) if result.wasSuccessful(): print("🎉 ALL TESTS PASSED - Backend API is working correctly!") print("✅ Frontend-backend communication issue has been resolved") print("✅ All API endpoints return proper JSON (not HTML)") print("✅ Politics API endpoint working with Article ID 74") print("✅ Movies API endpoints working properly") print("✅ Core section endpoints functional") print("✅ Environment variables configured correctly") print("✅ CMS endpoints working for basic functionality") else: print("❌ SOME TESTS FAILED - Check the detailed output above") print(f"Failed tests: {len(result.failures)}") print(f"Error tests: {len(result.errors)}")

#!/usr/bin/env python3 import requests import json import unittest import os import sys from datetime import datetime import time # Get the backend URL from the frontend .env file with open('/app/frontend/.env', 'r') as f: for line in f: if line.startswith('REACT_APP_BACKEND_URL='): BACKEND_URL = line.strip().split('=')[1].strip('"\'') break API_URL = f"{BACKEND_URL}/api" print(f"Testing API at: {API_URL}") class ComprehensiveBackendTest(unittest.TestCase): """Comprehensive test suite for the Blog CMS API after UI changes""" def setUp(self): """Set up test fixtures before each test method""" # Seed the database to ensure we have data to test with response = requests.post(f"{API_URL}/seed-database") self.assertEqual(response.status_code, 200, "Failed to seed database") print("Database seeded successfully") # Get categories for later use self.categories = requests.get(f"{API_URL}/categories").json() # Get articles for later use self.articles = requests.get(f"{API_URL}/articles").json() # Get movie reviews for later use self.movie_reviews = requests.get(f"{API_URL}/movie-reviews").json() # Get featured images for later use self.featured_images = requests.get(f"{API_URL}/featured-images").json() def test_01_health_check(self): """Test the health check endpoint""" print("\n--- Testing Health Check Endpoint ---") response = requests.get(f"{API_URL}/") self.assertEqual(response.status_code, 200, "Health check failed") data = response.json() self.assertEqual(data["message"], "Blog CMS API is running") self.assertEqual(data["status"], "healthy") print("✅ Health check endpoint working") def test_02_database_seeding(self): """Test database seeding functionality""" print("\n--- Testing Database Seeding ---") # Verify categories were seeded self.assertGreaterEqual(len(self.categories), 12, "Categories not seeded correctly") # Verify articles were seeded self.assertGreaterEqual(len(self.articles), 60, "Articles not seeded correctly") # Verify movie reviews were seeded self.assertGreaterEqual(len(self.movie_reviews), 3, "Movie reviews not seeded correctly") # Verify featured images were seeded self.assertGreaterEqual(len(self.featured_images), 5, "Featured images not seeded correctly") print(f"✅ Database seeding working correctly. Found {len(self.categories)} categories, {len(self.articles)} articles, {len(self.movie_reviews)} movie reviews, and {len(self.featured_images)} featured images.") def test_03_categories_api(self): """Test all category API endpoints""" print("\n--- Testing Categories API ---") # Test GET /categories response = requests.get(f"{API_URL}/categories") self.assertEqual(response.status_code, 200, "Failed to get categories") categories = response.json() self.assertIsInstance(categories, list, "Categories response is not a list") self.assertGreaterEqual(len(categories), 12, "Not enough categories returned") # Check category structure category = categories[0] required_fields = ["id", "name", "slug", "description", "created_at"] for field in required_fields: self.assertIn(field, category, f"Category missing required field: {field}") # Test pagination response = requests.get(f"{API_URL}/categories?skip=2&limit=3") self.assertEqual(response.status_code, 200, "Pagination request failed") paginated_categories = response.json() self.assertLessEqual(len(paginated_categories), 3, "Pagination limit not working") # Test POST /categories new_category = { "name": "Test Category", "slug": "test-category-" + datetime.now().strftime("%Y%m%d%H%M%S"), "description": "This is a test category" } response = requests.post(f"{API_URL}/categories", json=new_category) self.assertEqual(response.status_code, 200, "Failed to create category") created_category = response.json() self.assertEqual(created_category["name"], new_category["name"]) self.assertEqual(created_category["slug"], new_category["slug"]) # Test duplicate slug validation response = requests.post(f"{API_URL}/categories", json=new_category) self.assertEqual(response.status_code, 400, "Duplicate slug validation failed") print("✅ Categories API working correctly with proper validation") def test_04_articles_api(self): """Test all article API endpoints""" print("\n--- Testing Articles API ---") # Test GET /articles response = requests.get(f"{API_URL}/articles") self.assertEqual(response.status_code, 200, "Failed to get articles") articles = response.json() self.assertIsInstance(articles, list, "Articles response is not a list") self.assertGreaterEqual(len(articles), 60, "Not enough articles returned") # Check article structure article = articles[0] required_fields = ["id", "title", "summary", "image_url", "author", "published_at", "category", "view_count"] for field in required_fields: self.assertIn(field, article, f"Article missing required field: {field}") # Test pagination response = requests.get(f"{API_URL}/articles?skip=5&limit=10") self.assertEqual(response.status_code, 200, "Pagination request failed") paginated_articles = response.json() self.assertLessEqual(len(paginated_articles), 10, "Pagination limit not working") # Test GET /articles/category/{slug} if self.categories: category_slug = self.categories[0]["slug"] response = requests.get(f"{API_URL}/articles/category/{category_slug}") self.assertEqual(response.status_code, 200, f"Failed to get articles for category {category_slug}") category_articles = response.json() self.assertIsInstance(category_articles, list, "Category articles response is not a list") # Test invalid category response = requests.get(f"{API_URL}/articles/category/invalid-category-slug") self.assertEqual(response.status_code, 200, "Invalid category should return empty list") self.assertEqual(len(response.json()), 0, "Invalid category should return empty list") # Test GET /articles/most-read response = requests.get(f"{API_URL}/articles/most-read") self.assertEqual(response.status_code, 200, "Failed to get most read articles") most_read = response.json() self.assertIsInstance(most_read, list, "Most read articles response is not a list") self.assertGreaterEqual(len(most_read), 1, "No most read articles returned") # Check if articles are sorted by view_count if len(most_read) > 1: self.assertGreaterEqual(most_read[0]["view_count"], most_read[1]["view_count"], "Most read articles not sorted by view count") # Test GET /articles/featured response = requests.get(f"{API_URL}/articles/featured") if response.status_code == 200: featured = response.json() self.assertIn("is_featured", featured, "Featured article missing is_featured field") self.assertTrue(featured["is_featured"], "Featured article is_featured flag is not True") # Test GET /articles/{id} if self.articles: article_id = self.articles[0]["id"] initial_view_count = self.articles[0]["view_count"] response = requests.get(f"{API_URL}/articles/{article_id}") self.assertEqual(response.status_code, 200, f"Failed to get article with ID {article_id}") article = response.json() self.assertEqual(article["id"], article_id) self.assertIn("content", article, "Full article missing content field") # Test view count increment response = requests.get(f"{API_URL}/articles/{article_id}") self.assertEqual(response.status_code, 200) article_again = response.json() self.assertEqual(article_again["view_count"], initial_view_count + 2, "View count did not increment correctly") # Test invalid article ID response = requests.get(f"{API_URL}/articles/9999") self.assertEqual(response.status_code, 404, "Invalid article ID should return 404") # Test POST /articles if self.categories: category_id = self.categories[0]["id"] new_article = { "title": "Test Article " + datetime.now().strftime("%Y%m%d%H%M%S"), "content": "This is a test article content with detailed information.", "summary": "This is a test article summary.", "image_url": "https://example.com/test-image.jpg", "author": "Test Author", "is_published": True, "is_featured": False, "category_id": category_id } response = requests.post(f"{API_URL}/articles", json=new_article) self.assertEqual(response.status_code, 200, "Failed to create article") created_article = response.json() self.assertEqual(created_article["title"], new_article["title"]) self.assertEqual(created_article["content"], new_article["content"]) print("✅ Articles API working correctly with proper pagination, filtering, and view count increment") def test_05_movie_reviews_api(self): """Test all movie review API endpoints""" print("\n--- Testing Movie Reviews API ---") # Test GET /movie-reviews response = requests.get(f"{API_URL}/movie-reviews") self.assertEqual(response.status_code, 200, "Failed to get movie reviews") reviews = response.json() self.assertIsInstance(reviews, list, "Movie reviews response is not a list") self.assertGreaterEqual(len(reviews), 3, "Not enough movie reviews returned") # Check review structure review = reviews[0] required_fields = ["id", "title", "rating", "image_url", "created_at"] for field in required_fields: self.assertIn(field, review, f"Movie review missing required field: {field}") # Test pagination response = requests.get(f"{API_URL}/movie-reviews?skip=1&limit=2") self.assertEqual(response.status_code, 200, "Pagination request failed") paginated_reviews = response.json() self.assertLessEqual(len(paginated_reviews), 2, "Pagination limit not working") # Test GET /movie-reviews/{id} if self.movie_reviews: review_id = self.movie_reviews[0]["id"] response = requests.get(f"{API_URL}/movie-reviews/{review_id}") self.assertEqual(response.status_code, 200, f"Failed to get movie review with ID {review_id}") review = response.json() self.assertEqual(review["id"], review_id) self.assertIn("content", review, "Full review missing content field") # Test invalid review ID response = requests.get(f"{API_URL}/movie-reviews/9999") self.assertEqual(response.status_code, 404, "Invalid review ID should return 404") # Test POST /movie-reviews new_review = { "title": "Test Movie Review " + datetime.now().strftime("%Y%m%d%H%M%S"), "rating": 4.2, "content": "This is a test movie review with detailed critique.", "image_url": "https://example.com/test-movie.jpg", "director": "Test Director", "cast": "Actor 1, Actor 2, Actor 3", "genre": "Action/Drama", "reviewer": "Test Reviewer", "is_published": True } response = requests.post(f"{API_URL}/movie-reviews", json=new_review) self.assertEqual(response.status_code, 200, "Failed to create movie review") created_review = response.json() self.assertEqual(created_review["title"], new_review["title"]) self.assertEqual(created_review["rating"], new_review["rating"]) print("✅ Movie Reviews API working correctly with proper pagination and validation") def test_06_featured_images_api(self): """Test all featured image API endpoints""" print("\n--- Testing Featured Images API ---") # Test GET /featured-images response = requests.get(f"{API_URL}/featured-images") self.assertEqual(response.status_code, 200, "Failed to get featured images") images = response.json() self.assertIsInstance(images, list, "Featured images response is not a list") self.assertGreaterEqual(len(images), 5, "Not enough featured images returned") # Check image structure image = images[0] required_fields = ["id", "title", "image_url", "link_url", "order_index", "is_active"] for field in required_fields: self.assertIn(field, image, f"Featured image missing required field: {field}") # Test limit parameter response = requests.get(f"{API_URL}/featured-images?limit=3") self.assertEqual(response.status_code, 200, "Limit parameter request failed") limited_images = response.json() self.assertLessEqual(len(limited_images), 3, "Limit parameter not working") # Test POST /featured-images new_image = { "title": "Test Featured Image " + datetime.now().strftime("%Y%m%d%H%M%S"), "image_url": "https://example.com/test-featured.jpg", "link_url": "/articles/1", "description": "This is a test featured image", "order_index": 10, "is_active": True } response = requests.post(f"{API_URL}/featured-images", json=new_image) self.assertEqual(response.status_code, 200, "Failed to create featured image") created_image = response.json() self.assertEqual(created_image["title"], new_image["title"]) self.assertEqual(created_image["image_url"], new_image["image_url"]) print("✅ Featured Images API working correctly with proper limit parameter") def test_07_cors_configuration(self): """Test CORS configuration""" print("\n--- Testing CORS Configuration ---") # Test OPTIONS request response = requests.options(f"{API_URL}/", headers={ "Origin": "http://example.com", "Access-Control-Request-Method": "GET" }) self.assertEqual(response.status_code, 200, "OPTIONS request failed") self.assertIn("Access-Control-Allow-Origin", response.headers, "Missing Access-Control-Allow-Origin header") self.assertIn("Access-Control-Allow-Methods", response.headers, "Missing Access-Control-Allow-Methods header") self.assertIn("Access-Control-Allow-Headers", response.headers, "Missing Access-Control-Allow-Headers header") # Test cross-origin GET request response = requests.get(f"{API_URL}/", headers={ "Origin": "http://example.com" }) self.assertEqual(response.status_code, 200, "Cross-origin GET request failed") self.assertIn("Access-Control-Allow-Origin", response.headers, "Missing Access-Control-Allow-Origin header") print("✅ CORS configuration working correctly with proper headers") def test_08_analytics_tracking(self): """Test analytics tracking endpoint""" print("\n--- Testing Analytics Tracking Endpoint ---") # Test basic page view tracking tracking_data = { "page": "/home", "event": "page_view", "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36", "timestamp": datetime.now().isoformat() } response = requests.post(f"{API_URL}/analytics/track", json=tracking_data) self.assertEqual(response.status_code, 200, "Failed to track analytics data") data = response.json() self.assertEqual(data["status"], "success", "Analytics tracking status not successful") self.assertEqual(data["message"], "Analytics data tracked successfully", "Incorrect success message") # Test article view tracking if self.articles: article_id = self.articles[0]["id"] article_tracking = { "page": f"/articles/{article_id}", "event": "article_view", "article_id": article_id, "timestamp": datetime.now().isoformat() } response = requests.post(f"{API_URL}/analytics/track", json=article_tracking) self.assertEqual(response.status_code, 200, "Failed to track article view") self.assertEqual(response.json()["status"], "success", "Article view tracking status not successful") # Test movie review view tracking if self.movie_reviews: review_id = self.movie_reviews[0]["id"] review_tracking = { "page": f"/movie-reviews/{review_id}", "event": "movie_review_view", "review_id": review_id, "timestamp": datetime.now().isoformat() } response = requests.post(f"{API_URL}/analytics/track", json=review_tracking) self.assertEqual(response.status_code, 200, "Failed to track movie review view") self.assertEqual(response.json()["status"], "success", "Movie review tracking status not successful") print("✅ Analytics tracking endpoint working correctly for various event types") def test_09_error_handling(self): """Test error handling""" print("\n--- Testing Error Handling ---") # Test 404 for non-existent resource response = requests.get(f"{API_URL}/non-existent-endpoint") self.assertEqual(response.status_code, 404, "Non-existent endpoint should return 404") # Test 404 for non-existent article response = requests.get(f"{API_URL}/articles/9999") self.assertEqual(response.status_code, 404, "Non-existent article should return 404") # Test 404 for non-existent movie review response = requests.get(f"{API_URL}/movie-reviews/9999") self.assertEqual(response.status_code, 404, "Non-existent movie review should return 404") # Test 400 for validation error if self.categories: # Try to create a category with an existing slug existing_slug = self.categories[0]["slug"] duplicate_category = { "name": "Duplicate Category", "slug": existing_slug, "description": "This should fail validation" } response = requests.post(f"{API_URL}/categories", json=duplicate_category) self.assertEqual(response.status_code, 400, "Duplicate slug should return 400") print("✅ Error handling working correctly for 404 and 400 responses") def test_10_performance(self): """Test API performance""" print("\n--- Testing API Performance ---") # Test health check endpoint response time start_time = time.time() response = requests.get(f"{API_URL}/") end_time = time.time() health_check_time = end_time - start_time self.assertLess(health_check_time, 1.0, "Health check endpoint too slow") print(f"Health check response time: {health_check_time:.3f} seconds") # Test articles endpoint response time start_time = time.time() response = requests.get(f"{API_URL}/articles") end_time = time.time() articles_time = end_time - start_time self.assertLess(articles_time, 2.0, "Articles endpoint too slow") print(f"Articles endpoint response time: {articles_time:.3f} seconds") # Test categories endpoint response time start_time = time.time() response = requests.get(f"{API_URL}/categories") end_time = time.time() categories_time = end_time - start_time self.assertLess(categories_time, 1.0, "Categories endpoint too slow") print(f"Categories endpoint response time: {categories_time:.3f} seconds") print("✅ API performance is acceptable") if __name__ == "__main__": # Create a test suite suite = unittest.TestSuite() # Add all tests in order suite.addTest(ComprehensiveBackendTest("test_01_health_check")) suite.addTest(ComprehensiveBackendTest("test_02_database_seeding")) suite.addTest(ComprehensiveBackendTest("test_03_categories_api")) suite.addTest(ComprehensiveBackendTest("test_04_articles_api")) suite.addTest(ComprehensiveBackendTest("test_05_movie_reviews_api")) suite.addTest(ComprehensiveBackendTest("test_06_featured_images_api")) suite.addTest(ComprehensiveBackendTest("test_07_cors_configuration")) suite.addTest(ComprehensiveBackendTest("test_08_analytics_tracking")) suite.addTest(ComprehensiveBackendTest("test_09_error_handling")) suite.addTest(ComprehensiveBackendTest("test_10_performance")) # Run the tests runner = unittest.TextTestRunner(verbosity=2) runner.run(suite)

# Getting Started with Create React App This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app). ## Available Scripts In the project directory, you can run: ### `npm start` Runs the app in the development mode.\ Open [http://localhost:3000](http://localhost:3000) to view it in your browser. The page will reload when you make changes.\ You may also see any lint errors in the console. ### `npm test` Launches the test runner in the interactive watch mode.\ See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information. ### `npm run build` Builds the app for production to the `build` folder.\ It correctly bundles React in production mode and optimizes the build for the best performance. The build is minified and the filenames include the hashes.\ Your app is ready to be deployed! See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information. ### `npm run eject` **Note: this is a one-way operation. Once you `eject`, you can't go back!** If you aren't satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project. Instead, it will copy all the configuration files and the transitive dependencies (webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you're on your own. You don't have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn't feel obligated to use this feature. However we understand that this tool wouldn't be useful if you couldn't customize it when you are ready for it. ## Learn More You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started). To learn React, check out the [React documentation](https://reactjs.org/). ### Code Splitting This section has moved here: [https://facebook.github.io/create-react-app/docs/code-splitting](https://facebook.github.io/create-react-app/docs/code-splitting) ### Analyzing the Bundle Size This section has moved here: [https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size](https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size) ### Making a Progressive Web App This section has moved here: [https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app](https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app) ### Advanced Configuration This section has moved here: [https://facebook.github.io/create-react-app/docs/advanced-configuration](https://facebook.github.io/create-react-app/docs/advanced-configuration) ### Deployment This section has moved here: [https://facebook.github.io/create-react-app/docs/deployment](https://facebook.github.io/create-react-app/docs/deployment) ### `npm run build` fails to minify This section has moved here: [https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify](https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify)

{ "$schema": "https://ui.shadcn.com/schema.json", "style": "new-york", "rsc": false, "tsx": false, "tailwind": { "config": "tailwind.config.js", "css": "src/index.css", "baseColor": "neutral", "cssVariables": true, "prefix": "" }, "aliases": { "components": "@/components", "utils": "@/lib/utils", "ui": "@/components/ui", "lib": "@/lib", "hooks": "@/hooks" }, "iconLibrary": "lucide" }

const path = require('path'); module.exports = { webpack: { alias: { '@': path.resolve(__dirname, 'src'), }, }, devServer: { allowedHosts: 'all', client: { webSocketURL: 'auto://0.0.0.0:0/ws', }, }, };

{ "compilerOptions": { "baseUrl": ".", "paths": { "@/*": ["src/*"] } }, "include": ["src"] }

{ "name": "frontend", "version": "0.1.0", "private": true, "dependencies": { "@hookform/resolvers": "^5.0.1", "@radix-ui/react-accordion": "^1.2.8", "@radix-ui/react-alert-dialog": "^1.1.11", "@radix-ui/react-aspect-ratio": "^1.1.4", "@radix-ui/react-avatar": "^1.1.7", "@radix-ui/react-checkbox": "^1.2.3", "@radix-ui/react-collapsible": "^1.1.8", "@radix-ui/react-context-menu": "^2.2.12", "@radix-ui/react-dialog": "^1.1.11", "@radix-ui/react-dropdown-menu": "^2.1.12", "@radix-ui/react-hover-card": "^1.1.11", "@radix-ui/react-label": "^2.1.4", "@radix-ui/react-menubar": "^1.1.12", "@radix-ui/react-navigation-menu": "^1.2.10", "@radix-ui/react-popover": "^1.1.11", "@radix-ui/react-progress": "^1.1.4", "@radix-ui/react-radio-group": "^1.3.4", "@radix-ui/react-scroll-area": "^1.2.6", "@radix-ui/react-select": "^2.2.2", "@radix-ui/react-separator": "^1.1.4", "@radix-ui/react-slider": "^1.3.2", "@radix-ui/react-slot": "^1.2.0", "@radix-ui/react-switch": "^1.2.2", "@radix-ui/react-tabs": "^1.1.9", "@radix-ui/react-toast": "^1.2.11", "@radix-ui/react-toggle": "^1.1.6", "@radix-ui/react-toggle-group": "^1.1.7", "@radix-ui/react-tooltip": "^1.2.4", "axios": "^1.8.4", "class-variance-authority": "^0.7.1", "clsx": "^2.1.1", "cmdk": "^1.1.1", "cra-template": "1.2.0", "date-fns": "^4.1.0", "draft-js": "^0.11.7", "draftjs-to-html": "^0.9.1", "embla-carousel-react": "^8.6.0", "input-otp": "^1.4.2", "lucide-react": "^0.507.0", "next-themes": "^0.4.6", "react": "^19.0.0", "react-day-picker": "8.10.1", "react-dom": "^19.0.0", "react-draft-wysiwyg": "^1.15.0", "react-hook-form": "^7.56.2", "react-resizable-panels": "^3.0.1", "react-router-dom": "^7.5.1", "react-scripts": "5.0.1", "sonner": "^2.0.3", "tailwind-merge": "^3.2.0", "tailwindcss-animate": "^1.0.7", "vaul": "^1.1.2", "zod": "^3.24.4" }, "scripts": { "start": "craco start", "build": "craco build", "test": "craco test" }, "proxy": "http://localhost:8001", "browserslist": { "production": [ ">0.2%", "not dead", "not op_mini all" ], "development": [ "last 1 chrome version", "last 1 firefox version", "last 1 safari version" ] }, "devDependencies": { "@craco/craco": "^7.1.0", "@eslint/js": "9.23.0", "autoprefixer": "^10.4.20", "eslint": "9.23.0", "eslint-plugin-import": "2.31.0", "eslint-plugin-jsx-a11y": "6.10.2", "eslint-plugin-react": "7.37.4", "globals": "15.15.0", "postcss": "^8.4.49", "tailwindcss": "^3.4.17" } }

module.exports = { plugins: { tailwindcss: {}, autoprefixer: {}, }, }

<!doctype html> <html lang="en"> <head> <meta charset="utf-8" /> <meta name="viewport" content="width=device-width, initial-scale=1" /> <meta name="theme-color" content="#000000" /> <meta name="description" content="Tadka - Your ultimate destination for politics, movies & sports news. Stay updated with the latest happenings in entertainment, political updates, and sports coverage." /> <meta property="og:title" content="Tadka - Politics, Movies & Sports" /> <meta property="og:description" content="Stay updated with the latest in politics, movies, and sports. Your one-stop destination for comprehensive news coverage." /> <meta property="og:type" content="website" /> <meta name="keywords" content="politics, movies, sports, entertainment, news, bollywood, elections, cricket, football, cinema, governance" /> <!-- manifest.json provides metadata used when your web app is installed on a user's mobile device or desktop. See https://developers.google.com/web/fundamentals/web-app-manifest/ --> <!-- Notice the use of %PUBLIC_URL% in the tags above. It will be replaced with the URL of the `public` folder during the build. Only files inside the `public` folder can be referenced from the HTML. Unlike "/favicon.ico" or "favicon.ico", "%PUBLIC_URL%/favicon.ico" will work correctly both with client-side routing and a non-root public URL. Learn how to configure a non-root public URL by running `npm run build`. --> <title>Tadka - Politics, Movies & Sports</title> </head> <body> <noscript>You need to enable JavaScript to run this app.</noscript> <div id="root"></div> <!-- This HTML file is a template. If you open it directly in the browser, you will see an empty page. You can add webfonts, meta tags, or analytics to this file. The build step will place the bundled scripts into the <body> tag. To begin the development, run `npm start` or `yarn start`. To create a production bundle, use `npm run build` or `yarn build`. --> <a id="emergent-badge" target="_blank" href="https://app.emergent.sh/?utm_source=emergent-badge" style=" display: flex !important; align-items: center !important; position: fixed !important; bottom: 20px; right: 20px; text-decoration: none; padding: 6px 10px; font-family: -apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, Oxygen, Ubuntu, Cantarell, &quot;Open Sans&quot;, &quot;Helvetica Neue&quot;, sans-serif !important; font-size: 12px !important; z-index: 9999 !important; box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15) !important; border-radius: 8px !important; background-color: #ffffff !important; border: 1px solid rgba(255, 255, 255, 0.25) !important; " > <div style="display: flex; flex-direction: row; align-items: center" > <img style="width: 20px; height: 20px; margin-right: 8px" src="https://avatars.githubusercontent.com/in/1201222?s=120&u=2686cf91179bbafbc7a71bfbc43004cf9ae1acea&v=4" /> <p style=" color: #000000; font-family: -apple-system, BlinkMacSystemFont, &quot;Segoe UI&quot;, Roboto, Oxygen, Ubuntu, Cantarell, &quot;Open Sans&quot;, &quot;Helvetica Neue&quot;, sans-serif !important; font-size: 12px !important; align-items: center; margin-bottom: 0; " > Made with Emergent </p> </div> </a> <script> !(function (t, e) { var o, n, p, r; e.__SV || ((window.posthog = e), (e._i = []), (e.init = function (i, s, a) { function g(t, e) { var o = e.split("."); 2 == o.length && ((t = t[o[0]]), (e = o[1])), (t[e] = function () { t.push( [e].concat( Array.prototype.slice.call( arguments, 0, ), ), ); }); } ((p = t.createElement("script")).type = "text/javascript"), (p.crossOrigin = "anonymous"), (p.async = !0), (p.src = s.api_host.replace( ".i.posthog.com", "-assets.i.posthog.com", ) + "/static/array.js"), (r = t.getElementsByTagName( "script", )[0]).parentNode.insertBefore(p, r); var u = e; for ( void 0 !== a ? (u = e[a] = []) : (a = "posthog"), u.people = u.people || [], u.toString = function (t) { var e = "posthog"; return ( "posthog" !== a && (e += "." + a), t || (e += " (stub)"), e ); }, u.people.toString = function () { return u.toString(1) + ".people (stub)"; }, o = "init me ws ys ps bs capture je Di ks register register_once register_for_session unregister unregister_for_session Ps getFeatureFlag getFeatureFlagPayload isFeatureEnabled reloadFeatureFlags updateEarlyAccessFeatureEnrollment getEarlyAccessFeatures on onFeatureFlags onSurveysLoaded onSessionId getSurveys getActiveMatchingSurveys renderSurvey canRenderSurvey canRenderSurveyAsync identify setPersonProperties group resetGroups setPersonPropertiesForFlags resetPersonPropertiesForFlags setGroupPropertiesForFlags resetGroupPropertiesForFlags reset get_distinct_id getGroups get_session_id get_session_replay_url alias set_config startSessionRecording stopSessionRecording sessionRecordingStarted captureException loadToolbar get_property getSessionProperty Es $s createPersonProfile Is opt_in_capturing opt_out_capturing has_opted_in_capturing has_opted_out_capturing clear_opt_in_out_capturing Ss debug xs getPageViewId captureTraceFeedback captureTraceMetric".split( " ", ), n = 0; n < o.length; n++ ) g(u, o[n]); e._i.push([i, s, a]); }), (e.__SV = 1)); })(document, window.posthog || []); posthog.init("phc_yJW1VjHGGwmCbbrtczfqqNxgBDbhlhOWcdzcIJEOTFE", { api_host: "https://us.i.posthog.com", person_profiles: "identified_only", // or 'always' to create profiles for anonymous users as well }); </script> </body> </html>

.App { text-align: center; } .App-logo { height: 40vmin; pointer-events: none; } @media (prefers-reduced-motion: no-preference) { .App-logo { animation: App-logo-spin infinite 20s linear; } } .App-header { background-color: #0f0f10; min-height: 100vh; display: flex; flex-direction: column; align-items: center; justify-content: center; font-size: calc(10px + 2vmin); color: white; } .App-link { color: #61dafb; } @keyframes App-logo-spin { from { transform: rotate(0deg); } to { transform: rotate(360deg); } } /* Drag and Drop Styles */ .drag-drop-zone { transition: all 0.2s ease; position: relative; } .drag-drop-zone:hover { box-shadow: 0 0 15px rgba(59, 130, 246, 0.5); } .dragging { opacity: 0.5; transform: rotate(2deg); } .drag-drop-zone::after { content: ''; position: absolute; top: -2px; left: -2px; right: -2px; bottom: -2px; border: 2px dashed transparent; border-radius: 4px; pointer-events: none; transition: border-color 0.2s ease; } .drag-drop-zone:hover::after { border-color: #3b82f6; } /* Custom hover behavior for draggable section controls only */ .draggable-controls-container:hover .hover-controls { opacity: 1; }

import React, { useState, useEffect } from "react"; import "./App.css"; import { BrowserRouter, Routes, Route, useLocation } from "react-router-dom"; import Navigation from "./components/Navigation"; import Footer from "./components/Footer"; import SettingsModal from "./components/SettingsModal"; import { LanguageProvider } from "./contexts/LanguageContext"; import { ThemeProvider } from "./contexts/ThemeContext"; import { AuthProvider } from "./contexts/AuthContext"; import { DragDropProvider } from "./contexts/DragDropContext"; import Home from "./pages/Home"; import Politics from "./pages/Politics"; import Movies from "./pages/Movies"; import Sports from "./pages/Sports"; import Reviews from "./pages/Reviews"; import TrendingVideos from "./pages/TrendingVideos"; import GalleryPosts from "./pages/GalleryPosts"; import GalleryPost from "./pages/GalleryPost"; import HotTopicsGossipNews from "./pages/HotTopicsGossipNews"; import MovieReviews from "./pages/MovieReviews"; import ViewMovieContent from "./pages/ViewMovieContent"; import Gallery from "./pages/Gallery"; import Education from "./pages/Education"; import LatestNews from "./pages/LatestNews"; import TravelPics from "./pages/TravelPics"; import TadkaPics from "./pages/TadkaPics"; import TrailersTeasers from "./pages/TrailersTeasers"; import BoxOffice from "./pages/BoxOffice"; import MovieReleaseDates from "./pages/MovieReleaseDates"; import MovieSchedules from "./pages/MovieSchedules"; import EventsInterviews from "./pages/EventsInterviews"; import HealthFoodTopics from "./pages/HealthFoodTopics"; import FashionTravelTopics from "./pages/FashionTravelTopics"; import AIAndStockMarketNews from "./pages/AIAndStockMarketNews"; import TopInstaPics from "./pages/TopInstaPics"; import NewVideoSongs from "./pages/NewVideoSongs"; import TVShows from "./pages/TVShows"; import OTTReviews from "./pages/OTTReviews"; import OTTReleases from "./pages/OTTReleases"; import ArticlePage from "./pages/ArticlePage"; import SimpleArticlePage from "./pages/SimpleArticlePage"; import ImageGalleryPage from "./pages/ImageGalleryPage"; import VerticalImageGalleryPage from "./pages/VerticalImageGalleryPage"; import ActressGalleryPage from "./pages/ActressGalleryPage"; import AboutUs from "./pages/AboutUs"; import TermsOfUse from "./pages/TermsOfUse"; import PrivacyPolicy from "./pages/PrivacyPolicy"; import CookiePolicy from "./pages/CookiePolicy"; import Disclaimer from "./pages/Disclaimer"; import ContentGuidelines from "./pages/ContentGuidelines"; import VideoView from "./pages/VideoView"; import GalleryArticle from "./pages/GalleryArticle"; import Dashboard from "./components/CMS/Dashboard"; import CreateArticle from "./components/CMS/CreateArticle"; import CreateTopic from "./components/CMS/CreateTopic"; import AdminControls from "./components/CMS/AdminControls"; import ArticlePreview from "./components/CMS/ArticlePreview"; import Topics from "./pages/Topics"; import TopicDetail from "./pages/TopicDetail"; function App() { const [layoutEditMode, setLayoutEditMode] = useState(false); const handleLayoutModeChange = (isEditMode) => { setLayoutEditMode(isEditMode); }; // Component that has access to location inside BrowserRouter const AppContent = () => { const location = useLocation(); const isHomePage = location.pathname === '/' || location.pathname === '/home'; const [showWelcomeModal, setShowWelcomeModal] = useState(false); useEffect(() => { // Only check on component mount and route changes to home page if (isHomePage) { const hasConfiguredSettings = localStorage.getItem('tadka_settings_configured'); console.log('🏠 Checking first-time visit on homepage:', !hasConfiguredSettings); if (!hasConfiguredSettings) { // Set defaults if no preferences exist if (!localStorage.getItem('tadka_theme')) { localStorage.setItem('tadka_theme', 'light'); } if (!localStorage.getItem('tadka_state')) { localStorage.setItem('tadka_state', JSON.stringify(['Andhra Pradesh', 'Telangana'])); } if (!localStorage.getItem('tadka_language')) { localStorage.setItem('tadka_language', 'English'); } setShowWelcomeModal(true); } else { setShowWelcomeModal(false); } } else { // Ensure modal is closed when not on home page setShowWelcomeModal(false); } }, [location.pathname]); // Only depend on pathname, not isHomePage const handleWelcomeSettingsSave = () => { // Mark that user has configured settings to prevent modal from showing again console.log('🎯 App.js handleWelcomeSettingsSave called - marking settings as configured'); localStorage.setItem('tadka_settings_configured', 'true'); console.log('✅ Settings configured, modal should not appear again'); setShowWelcomeModal(false); // Settings are automatically saved in the modal }; return ( <> <div className="flex flex-col min-h-screen"> <Navigation onLayoutModeChange={handleLayoutModeChange} /> <div className="flex-grow"> <Routes> <Route path="/" element={<Home layoutEditMode={layoutEditMode} />} /> <Route path="/politics" element={<Politics />} /> <Route path="/movies" element={<Movies />} /> <Route path="/sports" element={<Sports />} /> <Route path="/reviews" element={<Reviews />} /> <Route path="/trending-videos" element={<TrendingVideos />} /> <Route path="/gallery" element={<Gallery />} /> <Route path="/gallery-posts" element={<GalleryPosts />} /> <Route path="/gallery-post/:id" element={<GalleryPost />} /> <Route path="/hot-topics-gossip-news" element={<HotTopicsGossipNews />} /> <Route path="/movie-reviews" element={<MovieReviews />} /> <Route path="/movie/:id" element={<ViewMovieContent />} /> <Route path="/education" element={<Education />} /> <Route path="/latest-news" element={<LatestNews />} /> <Route path="/travel-pics" element={<TravelPics />} /> <Route path="/tadka-pics" element={<TadkaPics />} /> <Route path="/trailers-teasers" element={<TrailersTeasers />} /> <Route path="/box-office" element={<BoxOffice />} /> <Route path="/movie-release-dates" element={<MovieReleaseDates />} /> <Route path="/movie-schedules" element={<MovieSchedules />} /> <Route path="/ott-releases" element={<OTTReleases />} /> <Route path="/new-video-songs" element={<NewVideoSongs />} /> <Route path="/tv-shows" element={<TVShows />} /> <Route path="/events-interviews" element={<EventsInterviews />} /> <Route path="/ott-reviews" element={<OTTReviews />} /> <Route path="/about-us" element={<AboutUs />} /> <Route path="/disclaimer" element={<Disclaimer />} /> <Route path="/cookie-policy" element={<CookiePolicy />} /> <Route path="/content-guidelines" element={<ContentGuidelines />} /> <Route path="/video/:id" element={<VideoView />} /> <Route path="/topics" element={<Topics />} /> <Route path="/topic/:id" element={<TopicDetail />} /> <Route path="/cms" element={<Dashboard />} /> <Route path="/cms/dashboard" element={<Dashboard />} /> <Route path="/cms/create" element={<CreateArticle />} /> <Route path="/cms/create-article" element={<CreateArticle />} /> <Route path="/cms/edit/:id" element={<CreateArticle />} /> <Route path="/cms/create-topic" element={<CreateTopic />} /> <Route path="/cms/preview/:id" element={<ArticlePreview />} /> <Route path="/cms/admin-controls" element={<AdminControls />} /> </Routes> </div> <Footer /> {/* Welcome Settings Modal - Shows on first visit and only on home page */} {isHomePage && showWelcomeModal && ( <SettingsModal isOpen={showWelcomeModal} onClose={() => setShowWelcomeModal(false)} onSave={handleWelcomeSettingsSave} onLayoutChange={handleLayoutModeChange} /> )} </div> </> ); }; const handleLayoutSave = () => { setLayoutEditMode(false); }; return ( <ThemeProvider> <AuthProvider> <DragDropProvider> <LanguageProvider> <div className="App min-h-screen bg-white"> <BrowserRouter> <AppContent /> </BrowserRouter> </div> </LanguageProvider> </DragDropProvider> </AuthProvider> </ThemeProvider> ); } export default App;